volute 0.33.0 → 0.34.0

package/dist/daemon.js

@@ -3,10 +3,18 @@ import {
   checkForUpdate,
   checkForUpdateCached,
   getCurrentVersion
-} from "./chunk-M7UL5S3Q.js";
+} from "./chunk-2IOP6PHB.js";
 import {
   computeTemplateHash
 } from "./chunk-PVY5W6QN.js";
+import {
+  acceptPending,
+  formatFileSize,
+  listPending,
+  rejectPending,
+  stageFile,
+  validateFilePath
+} from "./chunk-MLOQKQNB.js";
 import {
   PROMPT_DEFAULTS,
   PROMPT_KEYS,
@@ -45,7 +53,6 @@ import {
   recordInbound,
   recordOutbound,
   resolveMindToken,
-  setSummaryEventId,
   startMindFull,
   stopMindFull,
   subscribe as subscribe3,
@@ -54,53 +61,22 @@ import {
   tagUntaggedInbound,
   tagUntaggedOutbound,
   trackToolUse
-} from "./chunk-3Z2DPESO.js";
-import {
-  extractTextContent
-} from "./chunk-SKLSMHXO.js";
-import {
-  getActiveMinds,
-  onMindEvent,
-  stopAll
-} from "./chunk-LOEJ4HPQ.js";
+} from "./chunk-TAHX36HZ.js";
 import {
-  addMessage,
-  createChannel,
-  createConversation,
-  deleteConversationForUser,
-  findDMConversation,
-  fireWebhook,
-  getChannelByName,
-  getConversation,
-  getMessages,
-  getMessagesPaginated,
-  getParticipants,
-  getUnreadCounts,
-  initWebhook,
-  isConversationForMind,
-  isParticipant,
-  isParticipantOrOwner,
-  joinChannel,
-  leaveChannel,
-  listChannels,
-  listConversationsForMind,
-  listConversationsForUser,
-  listConversationsWithParticipants,
-  markConversationRead,
-  publish,
-  setConversationPrivate,
-  subscribe as subscribe2
-} from "./chunk-RVGLDGMI.js";
-import "./chunk-GY5HBI7A.js";
-import {
-  acceptPending,
-  formatFileSize,
-  listPending,
-  rejectPending,
-  stageFile,
-  validateFilePath
-} from "./chunk-ALEF47VT.js";
-import "./chunk-7J3HEVR7.js";
+  deleteSystemsConfig,
+  getAllDiscoveredExtensions,
+  getExtensionStandardSkills,
+  getLoadedExtensions,
+  installNpmExtension,
+  loadAllExtensions,
+  notifyExtensionsDaemonStart,
+  notifyExtensionsDaemonStop,
+  readSystemsConfig,
+  setExtensionEnabled,
+  uninstallNpmExtension,
+  writeSystemsConfig
+} from "./chunk-CVL5IGIR.js";
+import "./chunk-B2BVAIZ4.js";
 import {
   applyInitFiles,
   composeTemplate,
@@ -108,10 +84,39 @@ import {
   findTemplatesRoot,
   listFiles
 } from "./chunk-G53F3JA4.js";
+import {
+  SEED_SKILLS,
+  STANDARD_SKILLS,
+  autoUpdateMindSkills,
+  getSharedSkill,
+  getStandardSkillsWithExtensions,
+  importSkillFromDir,
+  initDefaultSkills,
+  installSkill,
+  isAutoUpdateSkillsEnabled,
+  listFilesRecursive,
+  listMindSkills,
+  listSharedSkills,
+  publishSkill,
+  removeSharedSkill,
+  sharedSkillsDir,
+  syncBuiltinSkills,
+  uninstallSkill,
+  updateSkill
+} from "./chunk-N3DNFPVA.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-OYAKCAVY.js";
+import "./chunk-V45JXOWY.js";
+import {
+  extractTextContent
+} from "./chunk-IS7WJ56Q.js";
+import {
+  getActiveMinds,
+  onMindEvent,
+  stopAll
+} from "./chunk-BTWAGDV5.js";
 import {
   findBridgeForChannel,
   findOpenClawSession,
@@ -125,27 +130,17 @@ import {
   resolveChannelMapping,
   setBridgeConfig,
   setChannelMapping
-} from "./chunk-RSX4OPZY.js";
+} from "./chunk-47ZPNLF4.js";
 import {
   loadMergedEnv,
   mindEnvPath,
   readEnv,
   sharedEnvPath,
   writeEnv
-} from "./chunk-2NGTS5UU.js";
+} from "./chunk-M3K5AARV.js";
 import {
   isHomeOnlyArchive
-} from "./chunk-I5KY25PQ.js";
-import {
-  deleteSystemsConfig,
-  getExtensionStandardSkills,
-  getLoadedExtensions,
-  loadAllExtensions,
-  notifyExtensionsDaemonStart,
-  notifyExtensionsDaemonStop,
-  readSystemsConfig,
-  writeSystemsConfig
-} from "./chunk-A2A4KLFE.js";
+} from "./chunk-6WAWMWR5.js";
 import "./chunk-PB65JZK2.js";
 import {
   approveUser,
@@ -162,31 +157,42 @@ import {
   listUsers,
   listUsersByType,
   setUserRole,
+  syncMindProfile,
   updateUserProfile,
   verifyUser
-} from "./chunk-JYVGHWEJ.js";
+} from "./chunk-BM474GX6.js";
+import {
+  addMessage,
+  createChannel,
+  createConversation,
+  deleteConversationForUser,
+  findDMConversation,
+  fireWebhook,
+  getChannelByName,
+  getConversation,
+  getMessages,
+  getMessagesPaginated,
+  getParticipants,
+  getUnreadCounts,
+  initWebhook,
+  isConversationForMind,
+  isParticipant,
+  isParticipantOrOwner,
+  joinChannel,
+  leaveChannel,
+  listChannels,
+  listConversationsForMind,
+  listConversationsForUser,
+  listConversationsWithParticipants,
+  markConversationRead,
+  publish,
+  setConversationPrivate,
+  subscribe as subscribe2
+} from "./chunk-E5C7OWZ2.js";
 import {
   broadcast,
   subscribe
-} from "./chunk-KVK2DLWI.js";
-import {
-  SEED_SKILLS,
-  STANDARD_SKILLS,
-  getSharedSkill,
-  getStandardSkillsWithExtensions,
-  importSkillFromDir,
-  initDefaultSkills,
-  installSkill,
-  listFilesRecursive,
-  listMindSkills,
-  listSharedSkills,
-  publishSkill,
-  removeSharedSkill,
-  sharedSkillsDir,
-  syncBuiltinSkills,
-  uninstallSkill,
-  updateSkill
-} from "./chunk-C7I35G4R.js";
+} from "./chunk-XWXBJQBE.js";
 import {
   aiCompleteUtility,
   getAiConfig,
@@ -203,16 +209,17 @@ import {
   setEnabledModels,
   setUtilityModel,
   unqualifyModelId
-} from "./chunk-QTUVYI7W.js";
+} from "./chunk-BFWHBQK4.js";
 import {
   logBuffer,
   logger_default
 } from "./chunk-YUIHSKR6.js";
+import "./chunk-D424ZQGI.js";
 import {
   exec,
   gitExec,
   resolveVoluteBin
-} from "./chunk-KIEPMIM5.js";
+} from "./chunk-U5BTYSAL.js";
 import {
   chownMindDir,
   createMindUser,
@@ -221,16 +228,15 @@ import {
   isIsolationEnabled,
   mindUserName,
   wrapForIsolation
-} from "./chunk-VH33ZWMW.js";
+} from "./chunk-BDK73LK6.js";
 import {
   isSetupComplete,
   readGlobalConfig,
   writeGlobalConfig
-} from "./chunk-N432I7QH.js";
+} from "./chunk-6OWJXUAR.js";
 import {
   readSessionFile
-} from "./chunk-UKVWJRKN.js";
-import "./chunk-D424ZQGI.js";
+} from "./chunk-PLDWHR4D.js";
 import {
   buildVoluteSlug,
   slugify
@@ -257,24 +263,26 @@ import {
   validateMindName,
   voluteHome,
   voluteSystemDir
-} from "./chunk-LRCG2JLP.js";
+} from "./chunk-N7BLAHNE.js";
 import {
   activity,
+  conversationParticipants,
   conversations,
   messages,
   mindHistory,
   sessions,
+  summaries,
   systemPrompts,
   turns,
   users
-} from "./chunk-RPZZSXV3.js";
+} from "./chunk-4JSR7YO7.js";
 import {
   __export
-} from "./chunk-K3NQKI34.js";
+} from "./chunk-7KJOFUNN.js";
 
 // src/daemon.ts
 import { randomBytes } from "crypto";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync12, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "fs";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync12, unlinkSync as unlinkSync2, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir3 } from "os";
 import { resolve as resolve19 } from "path";
 import { format } from "util";
@@ -450,160 +458,923 @@ var BridgeManager = class {
       logStream.write(chunk);
       lastStderr = chunk.toString().trim();
     });
-    if (child.pid) {
-      this.saveBridgePid(platform, child.pid);
-    }
-    this.bridges.set(platform, { child, platform });
-    this.restartTracker.reset(platform);
-    child.on("exit", (code) => {
-      const tracked = this.bridges.get(platform);
-      if (tracked?.child === child) {
-        this.bridges.delete(platform);
-      }
-      if (this.shuttingDown) return;
-      if (this.stopping.has(platform)) return;
-      blog.error(`bridge ${platform} exited with code ${code}`);
-      if (lastStderr) blog.warn(`bridge ${platform} last output: ${lastStderr}`);
-      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(platform);
-      if (!shouldRestart) {
-        blog.error(`bridge ${platform} crashed ${attempt} times \u2014 giving up`);
-        return;
-      }
-      blog.info(
-        `restarting bridge ${platform} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, in ${delay}ms`
+    if (child.pid) {
+      this.saveBridgePid(platform, child.pid);
+    }
+    this.bridges.set(platform, { child, platform });
+    this.restartTracker.reset(platform);
+    child.on("exit", (code) => {
+      const tracked = this.bridges.get(platform);
+      if (tracked?.child === child) {
+        this.bridges.delete(platform);
+      }
+      if (this.shuttingDown) return;
+      if (this.stopping.has(platform)) return;
+      blog.error(`bridge ${platform} exited with code ${code}`);
+      if (lastStderr) blog.warn(`bridge ${platform} last output: ${lastStderr}`);
+      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(platform);
+      if (!shouldRestart) {
+        blog.error(`bridge ${platform} crashed ${attempt} times \u2014 giving up`);
+        return;
+      }
+      blog.info(
+        `restarting bridge ${platform} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, in ${delay}ms`
+      );
+      setTimeout(() => {
+        if (this.shuttingDown || this.stopping.has(platform)) return;
+        this.startBridge(platform, daemonPort).catch((err) => {
+          blog.error(`failed to restart bridge ${platform}`, logger_default.errorData(err));
+        });
+      }, delay);
+    });
+    blog.info(`started bridge ${platform}`);
+  }
+  async stopBridge(platform) {
+    const tracked = this.bridges.get(platform);
+    if (!tracked) return;
+    this.stopping.add(platform);
+    this.bridges.delete(platform);
+    await new Promise((resolve20) => {
+      tracked.child.on("exit", () => resolve20());
+      try {
+        if (tracked.child.pid) {
+          process.kill(-tracked.child.pid, "SIGTERM");
+        } else {
+          tracked.child.kill("SIGTERM");
+        }
+      } catch (err) {
+        if (err instanceof Error && err.code !== "ESRCH") {
+          blog.warn(`failed to stop bridge ${platform}`, logger_default.errorData(err));
+        }
+        resolve20();
+      }
+      setTimeout(() => {
+        try {
+          if (tracked.child.pid) {
+            process.kill(-tracked.child.pid, "SIGKILL");
+          } else {
+            tracked.child.kill("SIGKILL");
+          }
+        } catch {
+        }
+        resolve20();
+      }, 5e3);
+    });
+    this.stopping.delete(platform);
+    this.restartTracker.reset(platform);
+    try {
+      this.removeBridgePid(platform);
+    } catch (err) {
+      blog.warn(`failed to remove PID file for bridge ${platform}`, logger_default.errorData(err));
+    }
+    blog.info(`stopped bridge ${platform}`);
+  }
+  async stopAll() {
+    this.shuttingDown = true;
+    const platforms = [...this.bridges.keys()];
+    await Promise.all(platforms.map((p) => this.stopBridge(p)));
+  }
+  getBridgeStatus() {
+    return [...this.bridges.entries()].map(([platform, tracked]) => ({
+      platform,
+      running: !tracked.child.killed
+    }));
+  }
+  isRunning(platform) {
+    const tracked = this.bridges.get(platform);
+    return tracked != null && !tracked.child.killed;
+  }
+  bridgePidPath(platform) {
+    return resolve2(voluteSystemDir(), "bridges", `${platform}.pid`);
+  }
+  saveBridgePid(platform, pid) {
+    const pidPath = this.bridgePidPath(platform);
+    mkdirSync(dirname(pidPath), { recursive: true });
+    writeFileSync(pidPath, String(pid));
+  }
+  removeBridgePid(platform) {
+    try {
+      unlinkSync(this.bridgePidPath(platform));
+    } catch (err) {
+      if (err instanceof Error && err.code !== "ENOENT") {
+        blog.warn(`failed to remove PID file for bridge ${platform}`, logger_default.errorData(err));
+      }
+    }
+  }
+  killOrphanBridge(platform) {
+    const pidPath = this.bridgePidPath(platform);
+    if (!existsSync2(pidPath)) return;
+    try {
+      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(-pid, "SIGTERM");
+        } catch {
+          try {
+            process.kill(pid, "SIGTERM");
+          } catch {
+          }
+        }
+        blog.warn(`killed orphan bridge ${platform} (pid ${pid})`);
+      }
+    } catch (err) {
+      if (err instanceof Error && err.code !== "ESRCH") {
+        blog.debug(`orphan bridge ${platform} cleanup: ${err}`);
+      }
+    }
+    try {
+      unlinkSync(pidPath);
+    } catch (err) {
+      if (err instanceof Error && err.code !== "ENOENT") {
+        blog.warn(`failed to clean up PID file for orphan bridge ${platform}`, logger_default.errorData(err));
+      }
+    }
+  }
+  resolveBuiltinBridge(platform) {
+    return searchUpwards("connectors", `${platform}-bridge.js`);
+  }
+};
+var instance = null;
+function initBridgeManager() {
+  if (instance) throw new Error("BridgeManager already initialized");
+  instance = new BridgeManager();
+  return instance;
+}
+function getBridgeManager() {
+  if (!instance) throw new Error("BridgeManager not initialized \u2014 call initBridgeManager() first");
+  return instance;
+}
+
+// src/lib/daemon/summarizer.ts
+import { and, desc, eq, gte, like, lt, sql } from "drizzle-orm";
+
+// src/lib/format-tool.ts
+function summarizeTool(name, input) {
+  if (input && typeof input === "object") {
+    const args = input;
+    const val = args.path ?? args.command ?? args.query ?? args.url;
+    if (typeof val === "string") {
+      const brief = val.length > 60 ? `${val.slice(0, 57)}...` : val;
+      return `[${name} ${brief}]`;
+    }
+  }
+  return `[${name}]`;
+}
+
+// src/lib/daemon/summarizer.ts
+var sLog = logger_default.child("summarizer");
+var SYSTEM_MIND = "_system";
+function getPeriodKey(date, period) {
+  switch (period) {
+    case "hour": {
+      const y = date.getFullYear();
+      const m = String(date.getMonth() + 1).padStart(2, "0");
+      const d = String(date.getDate()).padStart(2, "0");
+      const h = String(date.getHours()).padStart(2, "0");
+      return `${y}-${m}-${d}T${h}`;
+    }
+    case "day": {
+      const y = date.getFullYear();
+      const m = String(date.getMonth() + 1).padStart(2, "0");
+      const d = String(date.getDate()).padStart(2, "0");
+      return `${y}-${m}-${d}`;
+    }
+    case "week":
+      return getISOWeekKey(date);
+    case "month": {
+      const y = date.getFullYear();
+      const m = String(date.getMonth() + 1).padStart(2, "0");
+      return `${y}-${m}`;
+    }
+  }
+}
+function getISOWeekKey(date) {
+  const d = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+  const yearStart = new Date(d.getFullYear(), 0, 1);
+  const weekNum = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${d.getFullYear()}-W${String(weekNum).padStart(2, "0")}`;
+}
+function getPreviousPeriodKey(key, period) {
+  switch (period) {
+    case "hour": {
+      const d = /* @__PURE__ */ new Date(`${key.slice(0, 10)}T${key.slice(11)}:00:00`);
+      d.setHours(d.getHours() - 1);
+      return getPeriodKey(d, "hour");
+    }
+    case "day": {
+      const d = /* @__PURE__ */ new Date(`${key}T00:00:00`);
+      d.setDate(d.getDate() - 1);
+      return getPeriodKey(d, "day");
+    }
+    case "week": {
+      const d = isoWeekToDate(key);
+      d.setDate(d.getDate() - 7);
+      return getPeriodKey(d, "week");
+    }
+    case "month": {
+      const [y, m] = key.split("-").map(Number);
+      const d = new Date(y, m - 2, 1);
+      return getPeriodKey(d, "month");
+    }
+  }
+}
+function isoWeekToDate(weekKey) {
+  const [yearStr, weekStr] = weekKey.split("-W");
+  const year = parseInt(yearStr, 10);
+  const week = parseInt(weekStr, 10);
+  const jan4 = new Date(year, 0, 4);
+  const dayOfWeek = jan4.getDay() || 7;
+  const monday = new Date(jan4);
+  monday.setDate(jan4.getDate() - dayOfWeek + 1 + (week - 1) * 7);
+  return monday;
+}
+function localDateStr(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function utcDateTimeStr(d) {
+  return d.toISOString().replace("T", " ").slice(0, 19);
+}
+function getTimeRange(periodKey, period) {
+  switch (period) {
+    case "hour": {
+      const d = /* @__PURE__ */ new Date(`${periodKey.slice(0, 10)}T${periodKey.slice(11)}:00:00`);
+      const dEnd = new Date(d.getTime() + 36e5);
+      return { start: utcDateTimeStr(d), end: utcDateTimeStr(dEnd) };
+    }
+    case "day":
+      return { start: `${periodKey} 00:00:00`, end: `${periodKey} 23:59:59` };
+    case "week": {
+      const monday = isoWeekToDate(periodKey);
+      const sunday = new Date(monday);
+      sunday.setDate(monday.getDate() + 6);
+      return {
+        start: `${localDateStr(monday)} 00:00:00`,
+        end: `${localDateStr(sunday)} 23:59:59`
+      };
+    }
+    case "month": {
+      const [y, m] = periodKey.split("-").map(Number);
+      const lastDay = new Date(y, m, 0).getDate();
+      return {
+        start: `${periodKey}-01 00:00:00`,
+        end: `${periodKey}-${String(lastDay).padStart(2, "0")} 23:59:59`
+      };
+    }
+  }
+}
+async function gatherTurnEvents(mind, session, doneId) {
+  const db = await getDb();
+  const conditions = [
+    eq(mindHistory.mind, mind),
+    eq(mindHistory.type, "done"),
+    lt(mindHistory.id, doneId)
+  ];
+  if (session) {
+    conditions.push(eq(mindHistory.session, session));
+  }
+  const prevDone = await db.select({ id: mindHistory.id }).from(mindHistory).where(and(...conditions)).orderBy(desc(mindHistory.id)).limit(1);
+  const prevDoneId = prevDone.length > 0 ? prevDone[0].id : 0;
+  const turnConditions = [
+    eq(mindHistory.mind, mind),
+    sql`${mindHistory.id} > ${prevDoneId}`,
+    sql`${mindHistory.id} <= ${doneId}`
+  ];
+  if (session) {
+    turnConditions.push(eq(mindHistory.session, session));
+  }
+  const events = await db.select({
+    id: mindHistory.id,
+    type: mindHistory.type,
+    channel: mindHistory.channel,
+    session: mindHistory.session,
+    content: mindHistory.content,
+    metadata: mindHistory.metadata,
+    created_at: mindHistory.created_at
+  }).from(mindHistory).where(and(...turnConditions)).orderBy(mindHistory.id);
+  return {
+    events,
+    fromId: events.length > 0 ? events[0].id : doneId,
+    toId: doneId
+  };
+}
+async function gatherTurnEventsByTurnId(turnId) {
+  const db = await getDb();
+  const events = await db.select({
+    id: mindHistory.id,
+    type: mindHistory.type,
+    channel: mindHistory.channel,
+    session: mindHistory.session,
+    content: mindHistory.content,
+    metadata: mindHistory.metadata,
+    created_at: mindHistory.created_at
+  }).from(mindHistory).where(eq(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
+  return {
+    events,
+    fromId: events.length > 0 ? events[0].id : 0,
+    toId: events.length > 0 ? events[events.length - 1].id : 0
+  };
+}
+function buildTurnDeterministicSummary(events) {
+  const channels = /* @__PURE__ */ new Set();
+  const tools = [];
+  let hasInbound = false;
+  let hasOutbound = false;
+  for (const ev of events) {
+    if (ev.type === "inbound") {
+      hasInbound = true;
+      if (ev.channel) channels.add(ev.channel);
+    }
+    if (ev.type === "outbound" || ev.type === "text") {
+      hasOutbound = true;
+    }
+    if (ev.type === "tool_use" && ev.metadata) {
+      try {
+        const meta = JSON.parse(ev.metadata);
+        if (meta.name) tools.push(meta.name);
+      } catch (err) {
+        sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
+      }
+    }
+  }
+  const parts = [];
+  if (hasInbound) {
+    const channelList = [...channels];
+    parts.push(
+      channelList.length > 0 ? `Received message on ${channelList.join(", ")}` : "Received message"
+    );
+  }
+  if (tools.length > 0) {
+    const unique = [...new Set(tools)];
+    parts.push(`Used ${unique.join(", ")}`);
+  }
+  if (hasOutbound) {
+    parts.push("Sent response");
+  }
+  return parts.length > 0 ? `${parts.join(". ")}.` : "Turn completed.";
+}
+function buildTranscript(events) {
+  const lines = [];
+  for (const ev of events) {
+    switch (ev.type) {
+      case "inbound":
+        lines.push(`[inbound${ev.channel ? ` ${ev.channel}` : ""}] ${ev.content ?? ""}`);
+        break;
+      case "outbound":
+      case "text":
+        lines.push(`[response] ${(ev.content ?? "").slice(0, 500)}`);
+        break;
+      case "tool_use": {
+        let toolInfo = "tool";
+        if (ev.metadata) {
+          try {
+            const meta = JSON.parse(ev.metadata);
+            toolInfo = summarizeTool(meta.name ?? "tool", meta.input ?? {});
+          } catch (err) {
+            sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
+          }
+        }
+        lines.push(toolInfo);
+        break;
+      }
+      case "tool_result": {
+        const content = ev.content ?? "";
+        let isError = false;
+        if (ev.metadata) {
+          try {
+            const meta = JSON.parse(ev.metadata);
+            isError = !!meta.is_error;
+          } catch (err) {
+            sLog.debug(
+              `failed to parse tool_result metadata for event ${ev.id}`,
+              logger_default.errorData(err)
+            );
+          }
+        }
+        lines.push(isError ? "[result error]" : `[result] ${content.slice(0, 200)}`);
+        break;
+      }
+      case "thinking":
+        lines.push(`[thinking] ${(ev.content ?? "").slice(0, 300)}`);
+        break;
+    }
+  }
+  return lines.join("\n");
+}
+async function summarizeTurn(mind, session, channel, doneId, turnId) {
+  const { events, fromId, toId } = turnId ? await gatherTurnEventsByTurnId(turnId) : await gatherTurnEvents(mind, session, doneId);
+  if (events.length === 0) return;
+  const substantiveTypes = /* @__PURE__ */ new Set(["text", "outbound", "tool_use", "tool_result", "thinking"]);
+  const hasSubstantiveOutput = events.some((ev) => substantiveTypes.has(ev.type));
+  if (!hasSubstantiveOutput) {
+    sLog.info(
+      `skipping summary for interrupted turn ${turnId ?? "(no turn)"} (no substantive output)`
+    );
+    if (turnId) {
+      try {
+        const db2 = await getDb();
+        await db2.update(mindHistory).set({ turn_id: null }).where(and(eq(mindHistory.turn_id, turnId), eq(mindHistory.type, "inbound")));
+        await db2.update(messages).set({ turn_id: null }).where(eq(messages.turn_id, turnId));
+      } catch (err) {
+        sLog.error(`failed to un-tag events for interrupted turn ${turnId}`, logger_default.errorData(err));
+      }
+    }
+    return;
+  }
+  const tools = [];
+  for (const ev of events) {
+    if (ev.type === "tool_use" && ev.metadata) {
+      try {
+        const meta = JSON.parse(ev.metadata);
+        if (meta.name) tools.push(meta.name);
+      } catch (err) {
+        sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
+      }
+    }
+  }
+  const fromTime = events[0].created_at;
+  const toTime = events[events.length - 1].created_at;
+  let summaryText;
+  let deterministic;
+  const transcript = buildTranscript(events);
+  if (transcript.trim()) {
+    const summaryPrompt = await getPrompt("turn_summary");
+    const aiResult = await aiCompleteUtility(summaryPrompt, transcript);
+    if (aiResult) {
+      summaryText = aiResult;
+      deterministic = false;
+    } else {
+      summaryText = buildTurnDeterministicSummary(events);
+      deterministic = true;
+    }
+  } else {
+    summaryText = buildTurnDeterministicSummary(events);
+    deterministic = true;
+  }
+  const metadata = {
+    deterministic,
+    tool_count: tools.length,
+    tools: [...new Set(tools)],
+    from_id: fromId,
+    to_id: toId,
+    from_time: fromTime,
+    to_time: toTime
+  };
+  const periodKey = turnId ?? `${mind}-${doneId}`;
+  const db = await getDb();
+  let summaryId;
+  try {
+    const result = await db.insert(summaries).values({
+      mind,
+      period: "turn",
+      period_key: periodKey,
+      content: summaryText,
+      metadata: JSON.stringify(metadata)
+    }).onConflictDoNothing().returning({ id: summaries.id });
+    summaryId = result[0]?.id;
+    if (summaryId == null) {
+      const existing = await db.select({ id: summaries.id }).from(summaries).where(
+        and(
+          eq(summaries.mind, mind),
+          eq(summaries.period, "turn"),
+          eq(summaries.period_key, periodKey)
+        )
+      ).get();
+      summaryId = existing?.id;
+    }
+  } catch (err) {
+    sLog.error(
+      `failed to persist turn summary for ${mind} (events ${fromId}-${toId})`,
+      logger_default.errorData(err)
+    );
+    return;
+  }
+  if (turnId && summaryId != null) {
+    setSummaryId(turnId, summaryId).catch((err) => {
+      sLog.error(`failed to link summary to turn ${turnId}`, logger_default.errorData(err));
+    });
+  }
+  publish2(mind, {
+    mind,
+    type: "summary",
+    session,
+    channel,
+    content: summaryText,
+    metadata,
+    turnId
+  });
+}
+async function setSummaryId(turnId, summaryId) {
+  const db = await getDb();
+  await db.update(turns).set({ summary_id: summaryId }).where(eq(turns.id, turnId));
+}
+function getChildPeriod(period) {
+  switch (period) {
+    case "hour":
+      return "turn";
+    case "day":
+      return "hour";
+    case "week":
+    case "month":
+      return "day";
+  }
+}
+function getScopeInstruction(mind) {
+  if (mind === SYSTEM_MIND) {
+    return 'Write in third person, describing what the minds in the system did (e.g. "Alice explored...", "The system saw activity in..."). Reference minds by name.';
+  }
+  return 'Write in first person as the mind who performed the actions (e.g. "I explored...", "I worked on...").';
+}
+function buildPeriodicDeterministicSummary(sources, period, periodKey) {
+  if (sources.length === 0) return "";
+  switch (period) {
+    case "hour":
+      return `Activity during ${periodKey.slice(11)}:00: ${sources.join(" ")}`;
+    case "day":
+      return `Activity on ${periodKey}:
+
+${sources.join("\n\n")}`;
+    case "week":
+      return `Week ${periodKey} summary:
+
+${sources.join("\n\n")}`;
+    case "month":
+      return `${periodKey} summary:
+
+${sources.join("\n\n")}`;
+  }
+}
+async function gatherChildSummaries(mind, period, periodKey) {
+  const db = await getDb();
+  const childPeriod = getChildPeriod(period);
+  if (period === "hour") {
+    const { start: start2, end: end2 } = getTimeRange(periodKey, "hour");
+    const rows2 = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
+      and(
+        eq(summaries.mind, mind),
+        eq(summaries.period, childPeriod),
+        gte(summaries.created_at, start2),
+        lt(summaries.created_at, end2)
+      )
+    ).orderBy(summaries.created_at);
+    return {
+      texts: rows2.map((r) => r.content),
+      sourceIds: rows2.map((r) => r.id)
+    };
+  }
+  if (period === "day") {
+    const rows2 = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
+      and(
+        eq(summaries.mind, mind),
+        eq(summaries.period, childPeriod),
+        like(summaries.period_key, `${periodKey}%`)
+      )
+    ).orderBy(summaries.period_key);
+    return {
+      texts: rows2.map((r) => r.content),
+      sourceIds: rows2.map((r) => r.id)
+    };
+  }
+  const { start, end } = getTimeRange(periodKey, period);
+  const startKey = start.slice(0, 10);
+  const endKey = end.slice(0, 10);
+  const rows = await db.select({ id: summaries.id, content: summaries.content }).from(summaries).where(
+    and(
+      eq(summaries.mind, mind),
+      eq(summaries.period, childPeriod),
+      gte(summaries.period_key, startKey),
+      sql`${summaries.period_key} <= ${endKey}`
+    )
+  ).orderBy(summaries.period_key);
+  return {
+    texts: rows.map((r) => r.content),
+    sourceIds: rows.map((r) => r.id)
+  };
+}
+async function summarizePeriod(mind, period, periodKey) {
+  if (await summaryExists(mind, period, periodKey)) return false;
+  const db = await getDb();
+  const sources = await gatherChildSummaries(mind, period, periodKey);
+  if (sources.texts.length === 0) return false;
+  if (sources.texts.length === 1) {
+    try {
+      await db.insert(summaries).values({
+        mind,
+        period,
+        period_key: periodKey,
+        content: sources.texts[0],
+        metadata: JSON.stringify({
+          deterministic: false,
+          promoted: true,
+          source_count: 1,
+          source_ids: sources.sourceIds
+        })
+      }).onConflictDoNothing();
+    } catch (err) {
+      sLog.error(
+        `failed to persist promoted ${period} summary for ${mind} (${periodKey})`,
+        logger_default.errorData(err)
       );
-      setTimeout(() => {
-        if (this.shuttingDown || this.stopping.has(platform)) return;
-        this.startBridge(platform, daemonPort).catch((err) => {
-          blog.error(`failed to restart bridge ${platform}`, logger_default.errorData(err));
-        });
-      }, delay);
-    });
-    blog.info(`started bridge ${platform}`);
+      return false;
+    }
+    sLog.info(`promoted single-child ${period} summary for ${mind} (${periodKey})`);
+    return true;
   }
-  async stopBridge(platform) {
-    const tracked = this.bridges.get(platform);
-    if (!tracked) return;
-    this.stopping.add(platform);
-    this.bridges.delete(platform);
-    await new Promise((resolve20) => {
-      tracked.child.on("exit", () => resolve20());
-      try {
-        if (tracked.child.pid) {
-          process.kill(-tracked.child.pid, "SIGTERM");
-        } else {
-          tracked.child.kill("SIGTERM");
-        }
-      } catch (err) {
-        if (err instanceof Error && err.code !== "ESRCH") {
-          blog.warn(`failed to stop bridge ${platform}`, logger_default.errorData(err));
-        }
-        resolve20();
-      }
-      setTimeout(() => {
-        try {
-          if (tracked.child.pid) {
-            process.kill(-tracked.child.pid, "SIGKILL");
-          } else {
-            tracked.child.kill("SIGKILL");
-          }
-        } catch {
-        }
-        resolve20();
-      }, 5e3);
-    });
-    this.stopping.delete(platform);
-    this.restartTracker.reset(platform);
+  const promptKey = `meta_summary_${period}`;
+  const scopeInstruction = getScopeInstruction(mind);
+  const systemPrompt = await getPrompt(promptKey, { scope_instruction: scopeInstruction });
+  const userMessage = sources.texts.join("\n\n---\n\n");
+  let content;
+  let deterministic;
+  const aiResult = await aiCompleteUtility(systemPrompt, userMessage);
+  if (aiResult) {
+    content = aiResult;
+    deterministic = false;
+  } else {
+    content = buildPeriodicDeterministicSummary(sources.texts, period, periodKey);
+    deterministic = true;
+  }
+  const metadata = {
+    deterministic,
+    source_count: sources.texts.length,
+    source_ids: sources.sourceIds
+  };
+  try {
+    await db.insert(summaries).values({
+      mind,
+      period,
+      period_key: periodKey,
+      content,
+      metadata: JSON.stringify(metadata)
+    }).onConflictDoNothing();
+  } catch (err) {
+    sLog.error(
+      `failed to persist ${period} summary for ${mind} (${periodKey})`,
+      logger_default.errorData(err)
+    );
+    return false;
+  }
+  sLog.info(
+    `generated ${period} summary for ${mind} (${periodKey})${deterministic ? " [deterministic]" : ""}`
+  );
+  return true;
+}
+async function summarizeSystem(period, periodKey) {
+  if (await summaryExists(SYSTEM_MIND, period, periodKey)) return;
+  const db = await getDb();
+  const rows = await db.select({ mind: summaries.mind, content: summaries.content }).from(summaries).where(
+    and(
+      eq(summaries.period, period),
+      eq(summaries.period_key, periodKey),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).orderBy(summaries.mind);
+  if (rows.length === 0) return;
+  const minds = [...new Set(rows.map((r) => r.mind))];
+  const texts = rows.map((r) => `[${r.mind}] ${r.content}`);
+  const promptKey = `meta_summary_${period}`;
+  const scopeInstruction = getScopeInstruction(SYSTEM_MIND);
+  const systemPrompt = await getPrompt(promptKey, { scope_instruction: scopeInstruction });
+  const userMessage = texts.join("\n\n---\n\n");
+  let content;
+  let deterministic;
+  const aiResult = await aiCompleteUtility(systemPrompt, userMessage);
+  if (aiResult) {
+    content = aiResult;
+    deterministic = false;
+  } else {
+    content = buildPeriodicDeterministicSummary(texts, period, periodKey);
+    deterministic = true;
+  }
+  try {
+    await db.insert(summaries).values({
+      mind: SYSTEM_MIND,
+      period,
+      period_key: periodKey,
+      content,
+      metadata: JSON.stringify({ deterministic, minds, source_count: rows.length })
+    }).onConflictDoNothing();
+  } catch (err) {
+    sLog.error(`failed to persist system ${period} summary (${periodKey})`, logger_default.errorData(err));
+  }
+}
+async function mindsWithTurnSummaries(start, end) {
+  const db = await getDb();
+  const rows = await db.select({ mind: summaries.mind }).from(summaries).where(
+    and(
+      eq(summaries.period, "turn"),
+      gte(summaries.created_at, start),
+      lt(summaries.created_at, end),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).groupBy(summaries.mind);
+  return rows.map((r) => r.mind);
+}
+async function mindsWithSummaries(period, keyPattern) {
+  const db = await getDb();
+  const rows = await db.select({ mind: summaries.mind }).from(summaries).where(
+    and(
+      eq(summaries.period, period),
+      like(summaries.period_key, keyPattern),
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).groupBy(summaries.mind);
+  return rows.map((r) => r.mind);
+}
+async function mindsWithDailySummariesInRange(startKey, endKey) {
+  const db = await getDb();
+  const rows = await db.select({ mind: summaries.mind }).from(summaries).where(
+    and(
+      eq(summaries.period, "day"),
+      gte(summaries.period_key, startKey),
+      sql`${summaries.period_key} <= ${endKey}`,
+      sql`${summaries.mind} != ${SYSTEM_MIND}`
+    )
+  ).groupBy(summaries.mind);
+  return rows.map((r) => r.mind);
+}
+async function processHour(periodKey) {
+  const { start, end } = getTimeRange(periodKey, "hour");
+  const minds = await mindsWithTurnSummaries(start, end);
+  for (const mind of minds) {
     try {
-      this.removeBridgePid(platform);
+      await summarizePeriod(mind, "hour", periodKey);
     } catch (err) {
-      blog.warn(`failed to remove PID file for bridge ${platform}`, logger_default.errorData(err));
+      sLog.error(`failed to summarize hour for ${mind} (${periodKey})`, logger_default.errorData(err));
     }
-    blog.info(`stopped bridge ${platform}`);
   }
-  async stopAll() {
-    this.shuttingDown = true;
-    const platforms = [...this.bridges.keys()];
-    await Promise.all(platforms.map((p) => this.stopBridge(p)));
+  if (minds.length > 0) {
+    await summarizeSystem("hour", periodKey);
   }
-  getBridgeStatus() {
-    return [...this.bridges.entries()].map(([platform, tracked]) => ({
-      platform,
-      running: !tracked.child.killed
-    }));
+}
+async function processDay(periodKey) {
+  const minds = await mindsWithSummaries("hour", `${periodKey}%`);
+  for (const mind of minds) {
+    try {
+      await summarizePeriod(mind, "day", periodKey);
+    } catch (err) {
+      sLog.error(`failed to summarize day for ${mind} (${periodKey})`, logger_default.errorData(err));
+    }
   }
-  isRunning(platform) {
-    const tracked = this.bridges.get(platform);
-    return tracked != null && !tracked.child.killed;
+  if (minds.length > 0) {
+    await summarizeSystem("day", periodKey);
   }
-  bridgePidPath(platform) {
-    return resolve2(voluteSystemDir(), "bridges", `${platform}.pid`);
+}
+async function processWeek(periodKey) {
+  const { start, end } = getTimeRange(periodKey, "week");
+  const startKey = start.slice(0, 10);
+  const endKey = end.slice(0, 10);
+  const minds = await mindsWithDailySummariesInRange(startKey, endKey);
+  for (const mind of minds) {
+    try {
+      await summarizePeriod(mind, "week", periodKey);
+    } catch (err) {
+      sLog.error(`failed to summarize week for ${mind} (${periodKey})`, logger_default.errorData(err));
+    }
   }
-  saveBridgePid(platform, pid) {
-    const pidPath = this.bridgePidPath(platform);
-    mkdirSync(dirname(pidPath), { recursive: true });
-    writeFileSync(pidPath, String(pid));
+  if (minds.length > 0) {
+    await summarizeSystem("week", periodKey);
   }
-  removeBridgePid(platform) {
+}
+async function processMonth(periodKey) {
+  const minds = await mindsWithSummaries("day", `${periodKey}%`);
+  for (const mind of minds) {
     try {
-      unlinkSync(this.bridgePidPath(platform));
+      await summarizePeriod(mind, "month", periodKey);
     } catch (err) {
-      if (err instanceof Error && err.code !== "ENOENT") {
-        blog.warn(`failed to remove PID file for bridge ${platform}`, logger_default.errorData(err));
-      }
+      sLog.error(`failed to summarize month for ${mind} (${periodKey})`, logger_default.errorData(err));
     }
   }
-  killOrphanBridge(platform) {
-    const pidPath = this.bridgePidPath(platform);
-    if (!existsSync2(pidPath)) return;
+  if (minds.length > 0) {
+    await summarizeSystem("month", periodKey);
+  }
+}
+async function summaryExists(mind, period, periodKey) {
+  const db = await getDb();
+  const row = await db.select({ id: summaries.id }).from(summaries).where(
+    and(
+      eq(summaries.mind, mind),
+      eq(summaries.period, period),
+      eq(summaries.period_key, periodKey)
+    )
+  ).get();
+  return !!row;
+}
+async function backfill() {
+  const now = /* @__PURE__ */ new Date();
+  for (let i = 1; i <= 48; i++) {
     try {
-      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          try {
-            process.kill(pid, "SIGTERM");
-          } catch {
-          }
-        }
-        blog.warn(`killed orphan bridge ${platform} (pid ${pid})`);
+      const d = new Date(now);
+      d.setHours(d.getHours() - i);
+      const key = getPeriodKey(d, "hour");
+      if (!await summaryExists(SYSTEM_MIND, "hour", key)) {
+        await processHour(key);
       }
     } catch (err) {
-      if (err instanceof Error && err.code !== "ESRCH") {
-        blog.debug(`orphan bridge ${platform} cleanup: ${err}`);
+      sLog.error(`backfill failed for hour -${i}`, logger_default.errorData(err));
+    }
+  }
+  for (let i = 1; i <= 7; i++) {
+    try {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      const key = getPeriodKey(d, "day");
+      if (!await summaryExists(SYSTEM_MIND, "day", key)) {
+        await processDay(key);
       }
+    } catch (err) {
+      sLog.error(`backfill failed for day -${i}`, logger_default.errorData(err));
     }
+  }
+  for (let i = 1; i <= 4; i++) {
     try {
-      unlinkSync(pidPath);
+      const d = new Date(now);
+      d.setDate(d.getDate() - i * 7);
+      const key = getPeriodKey(d, "week");
+      if (!await summaryExists(SYSTEM_MIND, "week", key)) {
+        await processWeek(key);
+      }
     } catch (err) {
-      if (err instanceof Error && err.code !== "ENOENT") {
-        blog.warn(`failed to clean up PID file for orphan bridge ${platform}`, logger_default.errorData(err));
+      sLog.error(`backfill failed for week -${i}`, logger_default.errorData(err));
+    }
+  }
+  for (let i = 1; i <= 3; i++) {
+    try {
+      const d = new Date(now);
+      d.setMonth(d.getMonth() - i);
+      const key = getPeriodKey(d, "month");
+      if (!await summaryExists(SYSTEM_MIND, "month", key)) {
+        await processMonth(key);
       }
+    } catch (err) {
+      sLog.error(`backfill failed for month -${i}`, logger_default.errorData(err));
     }
   }
-  resolveBuiltinBridge(platform) {
-    return searchUpwards("connectors", `${platform}-bridge.js`);
+}
+var Summarizer = class {
+  interval = null;
+  lastHourKey = null;
+  hasBackfilled = false;
+  start() {
+    this.interval = setInterval(() => this.tick(), 5 * 6e4);
+    this.tick();
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  async tick() {
+    try {
+      if (!this.hasBackfilled) {
+        await backfill();
+        this.hasBackfilled = true;
+      }
+      const now = /* @__PURE__ */ new Date();
+      const currentHourKey = getPeriodKey(now, "hour");
+      if (this.lastHourKey && this.lastHourKey !== currentHourKey) {
+        await processHour(this.lastHourKey);
+      }
+      this.lastHourKey = currentHourKey;
+      const yesterday = new Date(now);
+      yesterday.setDate(yesterday.getDate() - 1);
+      const yesterdayKey = getPeriodKey(yesterday, "day");
+      if (!await summaryExists(SYSTEM_MIND, "day", yesterdayKey)) {
+        await processDay(yesterdayKey);
+      }
+      const currentWeekKey = getPeriodKey(now, "week");
+      const prevWeekKey = getPreviousPeriodKey(currentWeekKey, "week");
+      if (!await summaryExists(SYSTEM_MIND, "week", prevWeekKey)) {
+        await processWeek(prevWeekKey);
+      }
+      const currentMonthKey = getPeriodKey(now, "month");
+      const prevMonthKey = getPreviousPeriodKey(currentMonthKey, "month");
+      if (!await summaryExists(SYSTEM_MIND, "month", prevMonthKey)) {
+        await processMonth(prevMonthKey);
+      }
+    } catch (err) {
+      sLog.error("tick failed", logger_default.errorData(err));
+    }
   }
 };
-var instance = null;
-function initBridgeManager() {
-  if (instance) throw new Error("BridgeManager already initialized");
-  instance = new BridgeManager();
-  return instance;
-}
-function getBridgeManager() {
-  if (!instance) throw new Error("BridgeManager not initialized \u2014 call initBridgeManager() first");
-  return instance;
+var instance2 = null;
+function initSummarizer() {
+  if (instance2) throw new Error("Summarizer already initialized");
+  instance2 = new Summarizer();
+  return instance2;
 }
 
 // src/lib/history-cleanup.ts
-import { and, eq, lt } from "drizzle-orm";
+import { and as and2, eq as eq2, lt as lt2 } from "drizzle-orm";
 var LOG_RETENTION_MS = 24 * 60 * 60 * 1e3;
 async function cleanExpiredLogs() {
   const db = await getDb();
   const cutoff = new Date(Date.now() - LOG_RETENTION_MS).toISOString().replace("T", " ").slice(0, 19);
-  await db.delete(mindHistory).where(and(eq(mindHistory.type, "log"), lt(mindHistory.created_at, cutoff)));
+  await db.delete(mindHistory).where(and2(eq2(mindHistory.type, "log"), lt2(mindHistory.created_at, cutoff)));
 }
 
 // src/lib/shared.ts
@@ -977,7 +1748,7 @@ async function generateImage(model, prompt) {
 
 // src/web/middleware/auth.ts
 import { timingSafeEqual } from "crypto";
-import { eq as eq2, lt as lt2 } from "drizzle-orm";
+import { eq as eq3, lt as lt3 } from "drizzle-orm";
 import { getCookie } from "hono/cookie";
 import { createMiddleware } from "hono/factory";
 function isValidDaemonToken(token) {
@@ -1000,14 +1771,14 @@ async function createSession(userId) {
 async function deleteSession(sessionId) {
   sessionCache.delete(sessionId);
   const db = await getDb();
-  await db.delete(sessions).where(eq2(sessions.id, sessionId));
+  await db.delete(sessions).where(eq3(sessions.id, sessionId));
 }
 async function getSessionUserId(sessionId) {
   const db = await getDb();
-  const row = await db.select().from(sessions).where(eq2(sessions.id, sessionId)).get();
+  const row = await db.select().from(sessions).where(eq3(sessions.id, sessionId)).get();
   if (!row) return void 0;
   if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
-    await db.delete(sessions).where(eq2(sessions.id, sessionId));
+    await db.delete(sessions).where(eq3(sessions.id, sessionId));
     return void 0;
   }
   return row.userId;
@@ -1015,7 +1786,7 @@ async function getSessionUserId(sessionId) {
 async function cleanExpiredSessions() {
   const db = await getDb();
   const cutoff = Date.now() - SESSION_MAX_AGE;
-  await db.delete(sessions).where(lt2(sessions.createdAt, cutoff));
+  await db.delete(sessions).where(lt3(sessions.createdAt, cutoff));
 }
 var requireAdmin = createMiddleware(async (c, next) => {
   const user = c.get("user");
@@ -1136,7 +1907,14 @@ var app = new Hono().post("/restart", requireAdmin, (c) => {
   });
 }).get("/info", (c) => {
   const config2 = readSystemsConfig();
-  return c.json({ system: config2?.system ?? null });
+  const globalConfig = readGlobalConfig();
+  return c.json({ system: config2?.system ?? null, name: globalConfig.name ?? null });
+}).put("/info", requireAdmin, zValidator("json", z.object({ name: z.string() })), (c) => {
+  const { name } = c.req.valid("json");
+  const config2 = readGlobalConfig();
+  config2.name = name.trim() || void 0;
+  writeGlobalConfig(config2);
+  return c.json({ name: config2.name ?? null });
 }).post(
   "/register",
   requireAdmin,
@@ -1382,15 +2160,17 @@ var app = new Hono().post("/restart", requireAdmin, (c) => {
   zValidator(
     "json",
     z.object({
-      spiritModel: z.string().nullable(),
+      spiritModel: z.string().nullable().optional(),
       utilityModel: z.string().nullable()
     })
   ),
   (c) => {
     const { spiritModel, utilityModel } = c.req.valid("json");
     const config2 = readGlobalConfig();
-    config2.spiritModel = spiritModel ?? void 0;
-    writeGlobalConfig(config2);
+    if (spiritModel !== void 0) {
+      config2.spiritModel = spiritModel ?? void 0;
+      writeGlobalConfig(config2);
+    }
     setUtilityModel(utilityModel ?? void 0);
     return c.json({ ok: true });
   }
@@ -1505,7 +2285,54 @@ var app = new Hono().post("/restart", requireAdmin, (c) => {
     setTimeout(() => oauthFlows.delete(flowId), 3e4);
   }
   return c.json(result);
-});
+}).get("/mind-defaults", requireAdmin, (c) => {
+  const config2 = readGlobalConfig();
+  return c.json(config2.mindDefaults ?? {});
+}).put(
+  "/mind-defaults",
+  requireAdmin,
+  zValidator(
+    "json",
+    z.object({
+      cognition: z.object({
+        model: z.string().optional(),
+        thinkingLevel: z.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+        maxThinkingTokens: z.number().nonnegative().optional(),
+        tokenBudget: z.number().nonnegative().optional(),
+        tokenBudgetPeriodMinutes: z.number().positive().optional(),
+        compaction: z.object({ maxContextTokens: z.number().positive().optional() }).optional()
+      }).optional(),
+      sleep: z.object({
+        enabled: z.boolean().optional(),
+        schedule: z.object({ sleep: z.string(), wake: z.string() }).optional(),
+        wakeTriggers: z.object({
+          mentions: z.boolean().optional(),
+          dms: z.boolean().optional(),
+          channels: z.array(z.string()).optional(),
+          senders: z.array(z.string()).optional()
+        }).optional()
+      }).optional(),
+      schedules: z.array(
+        z.object({
+          id: z.string().min(1),
+          cron: z.string().optional(),
+          message: z.string().optional(),
+          script: z.string().optional(),
+          session: z.string().optional(),
+          enabled: z.boolean(),
+          whileSleeping: z.enum(["skip", "queue", "trigger-wake"]).optional()
+        })
+      ).optional()
+    })
+  ),
+  (c) => {
+    const mindDefaults = c.req.valid("json");
+    const config2 = readGlobalConfig();
+    config2.mindDefaults = mindDefaults;
+    writeGlobalConfig(config2);
+    return c.json({ ok: true });
+  }
+);
 var oauthFlows = /* @__PURE__ */ new Map();
 var OAUTH_FLOW_TTL_MS = 10 * 60 * 1e3;
 function cleanupOAuthFlows() {
@@ -1563,7 +2390,7 @@ import { csrf } from "hono/csrf";
 import { HTTPException } from "hono/http-exception";
 
 // src/web/api/activity.ts
-import { desc } from "drizzle-orm";
+import { desc as desc2 } from "drizzle-orm";
 import { Hono as Hono2 } from "hono";
 import { streamSSE as streamSSE2 } from "hono/streaming";
 var app2 = new Hono2().get("/events", async (c) => {
@@ -1574,7 +2401,7 @@ var app2 = new Hono2().get("/events", async (c) => {
       let recentActivity = [];
       try {
         const db = await getDb();
-        recentActivity = await db.select().from(activity).orderBy(desc(activity.created_at)).limit(50);
+        recentActivity = await db.select().from(activity).orderBy(desc2(activity.created_at)).limit(50);
         recentActivity = recentActivity.map((row) => ({
           ...row,
           metadata: row.metadata ? JSON.parse(row.metadata) : null
@@ -1900,7 +2727,7 @@ import { Hono as Hono4 } from "hono";
 import { z as z3 } from "zod";
 
 // src/lib/puppets.ts
-import { and as and2, eq as eq3 } from "drizzle-orm";
+import { and as and3, eq as eq4 } from "drizzle-orm";
 async function findOrCreatePuppet(platform, platformId, displayName) {
   const username = `${platform}:${platformId}`;
   const db = await getDb();
@@ -1909,10 +2736,10 @@ async function findOrCreatePuppet(platform, platformId, displayName) {
     username: users.username,
     display_name: users.display_name,
     avatar: users.avatar
-  }).from(users).where(and2(eq3(users.username, username), eq3(users.user_type, "puppet"))).get();
+  }).from(users).where(and3(eq4(users.username, username), eq4(users.user_type, "puppet"))).get();
   if (existing) {
     if (existing.display_name !== displayName) {
-      await db.update(users).set({ display_name: displayName }).where(eq3(users.id, existing.id));
+      await db.update(users).set({ display_name: displayName }).where(eq4(users.id, existing.id));
       existing.display_name = displayName;
     }
     return existing;
@@ -1938,7 +2765,7 @@ async function findOrCreatePuppet(platform, platformId, displayName) {
         username: users.username,
         display_name: users.display_name,
         avatar: users.avatar
-      }).from(users).where(and2(eq3(users.username, username), eq3(users.user_type, "puppet"))).get();
+      }).from(users).where(and3(eq4(users.username, username), eq4(users.user_type, "puppet"))).get();
       if (retried) return retried;
     }
     throw err;
@@ -2020,7 +2847,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-AWI5SZW2.js");
+    const { addParticipant } = await import("./conversations-HL2JP5GI.js");
     await addParticipant(channel.id, puppet.id);
   }
   const contentBlocks = body.content;
@@ -2113,8 +2940,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-NBJF5D26.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-MWW3BTS4.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.filter((ap) => {
@@ -2916,6 +3743,44 @@ var env_default = app6;
 import { Hono as Hono8 } from "hono";
 var app7 = new Hono8().get("/", (c) => {
   return c.json(getLoadedExtensions());
+}).get("/all", (c) => {
+  return c.json(getAllDiscoveredExtensions());
+}).put("/:id/enabled", async (c) => {
+  const { id } = c.req.param();
+  const body = await c.req.json().catch(() => null);
+  if (!body || typeof body.enabled !== "boolean") {
+    return c.json({ error: "enabled must be a boolean" }, 400);
+  }
+  try {
+    setExtensionEnabled(id, body.enabled);
+  } catch (err) {
+    return c.json({ error: err.message }, 404);
+  }
+  return c.json({ ok: true, requiresRestart: true });
+}).post("/install", async (c) => {
+  const body = await c.req.json();
+  const pkg = body.package?.trim();
+  if (!pkg) {
+    return c.json({ error: "package is required" }, 400);
+  }
+  try {
+    await installNpmExtension(pkg);
+    return c.json({ ok: true, requiresRestart: true });
+  } catch (err) {
+    const message = err.message;
+    const isValidation = message.includes("already installed") || message.includes("Invalid package");
+    return c.json({ error: message }, isValidation ? 400 : 500);
+  }
+}).delete("/uninstall/:package", async (c) => {
+  const pkg = c.req.param("package");
+  try {
+    await uninstallNpmExtension(pkg);
+    return c.json({ ok: true, requiresRestart: true });
+  } catch (err) {
+    const message = err.message;
+    const isValidation = message.includes("not installed");
+    return c.json({ error: message }, isValidation ? 400 : 500);
+  }
 });
 var extensions_default = app7;
 
@@ -2927,7 +3792,7 @@ async function notifyMind(mindName, message) {
   const entry = await findMind(mindName);
   if (!entry) return;
   try {
-    const { sendSystemMessage } = await import("./system-chat-JAPOJ3KE.js");
+    const { sendSystemMessage } = await import("./system-chat-TYLOL7SX.js");
     await sendSystemMessage(mindName, message);
   } catch (err) {
     logger_default.warn(`[file-sharing] notify mind ${mindName} failed`, logger_default.errorData(err));
@@ -3050,6 +3915,7 @@ var app8 = new Hono9().post("/:name/files/send", requireSelf(), async (c) => {
 var file_sharing_default = app8;
 
 // src/web/api/files.ts
+import { mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "fs";
 import { readFile, realpath, stat } from "fs/promises";
 import { extname as extname2, resolve as resolve7 } from "path";
 import { Hono as Hono10 } from "hono";
@@ -3061,11 +3927,46 @@ var AVATAR_MIME2 = {
   ".webp": "image/webp"
 };
 var MAX_AVATAR_SIZE2 = 2 * 1024 * 1024;
-var app9 = new Hono10().get("/:name/avatar", async (c) => {
+var app9 = new Hono10().post("/:name/avatar", 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 dir = mindDir(name);
+  const body = await c.req.parseBody();
+  const file = body.file;
+  if (!(file instanceof File)) {
+    return c.json({ error: "No file uploaded" }, 400);
+  }
+  if (file.size > MAX_AVATAR_SIZE2) {
+    return c.json({ error: "File too large (max 2MB)" }, 400);
+  }
+  const ext = extname2(file.name).toLowerCase();
+  if (!AVATAR_MIME2[ext]) {
+    return c.json({ error: "Invalid file type (png, jpg, gif, webp only)" }, 400);
+  }
+  const dir = entry.dir ?? mindDir(name);
+  const homeDir = resolve7(dir, "home");
+  const filename = `avatar${ext}`;
+  const avatarPath = resolve7(homeDir, filename);
+  const config2 = readVoluteConfig(dir) ?? {};
+  const oldAvatar = config2.profile?.avatar;
+  if (oldAvatar && oldAvatar !== filename) {
+    rmSync3(resolve7(homeDir, oldAvatar), { force: true });
+  }
+  const buffer2 = Buffer.from(await file.arrayBuffer());
+  mkdirSync4(homeDir, { recursive: true });
+  writeFileSync4(avatarPath, buffer2);
+  const profile = config2.profile ?? {};
+  profile.avatar = filename;
+  config2.profile = profile;
+  writeVoluteConfig(dir, config2);
+  await syncMindProfile(name, profile);
+  broadcast({ type: "profile_updated", mind: name, summary: `${name} avatar updated` });
+  return c.json({ ok: true, avatar: filename });
+}).get("/:name/avatar", async (c) => {
+  const name = c.req.param("name");
+  const entry = await findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  const dir = entry.dir ?? mindDir(name);
   const config2 = readVoluteConfig(dir);
   if (!config2?.profile?.avatar) return c.json({ error: "No avatar configured" }, 404);
   const ext = extname2(config2.profile.avatar).toLowerCase();
@@ -3100,25 +4001,29 @@ var app9 = new Hono10().get("/:name/avatar", async (c) => {
 var files_default = app9;
 
 // src/web/api/history.ts
-import { and as and3, desc as desc2, eq as eq4, inArray, sql } from "drizzle-orm";
+import { and as and4, desc as desc3, eq as eq5, gte as gte2, inArray, sql as sql2 } from "drizzle-orm";
 import { Hono as Hono11 } from "hono";
 var history = new Hono11().get("/turns", async (c) => {
   const mindFilter = c.req.query("mind");
   const turnIdFilter = c.req.query("turnId");
+  const turnIdsFilter = c.req.query("turnIds");
   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 (mindFilter) conditions.push(eq5(turns.mind, mindFilter));
+  if (turnIdFilter) conditions.push(eq5(turns.id, turnIdFilter));
+  if (turnIdsFilter) {
+    const ids = turnIdsFilter.split(",").filter(Boolean);
+    if (ids.length > 0) conditions.push(inArray(turns.id, ids));
+  }
+  const turnRows = await db.select().from(turns).where(conditions.length > 0 ? and4(...conditions) : void 0).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(and3(eq4(mindHistory.type, "summary"), inArray(mindHistory.turn_id, turnIds)));
+  const summaryRows = await db.select().from(summaries).where(and4(eq5(summaries.period, "turn"), inArray(summaries.period_key, 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 });
+    summaryByTurn.set(s.period_key, { content: s.content, metadata: s.metadata });
   }
   const historyMsgRows = await db.select({
     id: mindHistory.id,
@@ -3130,9 +4035,9 @@ var history = new Hono11().get("/turns", async (c) => {
     turn_id: mindHistory.turn_id,
     created_at: mindHistory.created_at
   }).from(mindHistory).where(
-    and3(
+    and4(
       inArray(mindHistory.turn_id, turnIds),
-      sql`${mindHistory.type} IN ('inbound', 'outbound')`
+      sql2`${mindHistory.type} IN ('inbound', 'outbound')`
     )
   ).orderBy(mindHistory.created_at);
   const msgsByTurnChannel = /* @__PURE__ */ new Map();
@@ -3191,13 +4096,92 @@ var history = new Hono11().get("/turns", async (c) => {
     }).from(mindHistory).where(inArray(mindHistory.id, triggerIds));
     for (const r of triggerRows) triggerMap.set(r.id, r);
   }
+  const allChannelSlugs = /* @__PURE__ */ new Set();
+  for (const [, channels] of msgsByTurnChannel) {
+    for (const ch of channels.keys()) allChannelSlugs.add(ch);
+  }
+  const dmSlugMinds = /* @__PURE__ */ new Map();
+  for (const [turnId, channels] of msgsByTurnChannel) {
+    const mindName = turnMindMap.get(turnId);
+    if (!mindName) continue;
+    for (const ch of channels.keys()) {
+      if (ch.startsWith("@")) {
+        let minds = dmSlugMinds.get(ch);
+        if (!minds) {
+          minds = /* @__PURE__ */ new Set();
+          dmSlugMinds.set(ch, minds);
+        }
+        minds.add(mindName);
+      }
+    }
+  }
+  const channelIdMap = /* @__PURE__ */ new Map();
+  try {
+    if (allChannelSlugs.size > 0) {
+      const channelNames = [...allChannelSlugs].filter((s) => !s.startsWith("@")).map((s) => {
+        let name = s;
+        if (name.startsWith("#")) name = name.slice(1);
+        const colonIdx = name.indexOf(":");
+        if (colonIdx >= 0) name = name.substring(colonIdx + 1);
+        return { slug: s, name };
+      });
+      if (channelNames.length > 0) {
+        const channelRows = await db.select({ id: conversations.id, name: conversations.name }).from(conversations).where(
+          and4(
+            eq5(conversations.type, "channel"),
+            inArray(
+              conversations.name,
+              channelNames.map((c2) => c2.name)
+            )
+          )
+        );
+        const nameToId = new Map(channelRows.map((r) => [r.name, r.id]));
+        for (const { slug, name } of channelNames) {
+          const id = nameToId.get(name);
+          if (id) channelIdMap.set(slug, id);
+        }
+      }
+      const dmSlugs = [...dmSlugMinds.keys()];
+      if (dmSlugs.length > 0) {
+        const targetNames = dmSlugs.map((s) => s.slice(1));
+        const cp2 = db.$with("cp2").as(
+          db.select({
+            conversation_id: conversationParticipants.conversation_id,
+            username: users.username
+          }).from(conversationParticipants).innerJoin(users, eq5(conversationParticipants.user_id, users.id))
+        );
+        const dmRows = await db.with(cp2).select({
+          id: conversations.id,
+          targetUsername: users.username
+        }).from(conversations).innerJoin(
+          conversationParticipants,
+          eq5(conversations.id, conversationParticipants.conversation_id)
+        ).innerJoin(users, eq5(conversationParticipants.user_id, users.id)).where(and4(eq5(conversations.type, "dm"), inArray(users.username, targetNames)));
+        for (const row of dmRows) {
+          const slug = `@${row.targetUsername}`;
+          const mindNames = dmSlugMinds.get(slug);
+          if (mindNames && !channelIdMap.has(slug)) {
+            const mindCheck = await db.select({ id: conversationParticipants.user_id }).from(conversationParticipants).innerJoin(users, eq5(conversationParticipants.user_id, users.id)).where(
+              and4(
+                eq5(conversationParticipants.conversation_id, row.id),
+                inArray(users.username, [...mindNames])
+              )
+            ).get();
+            if (mindCheck) channelIdMap.set(slug, row.id);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    logger_default.warn("Failed to resolve channel slugs to conversation IDs", logger_default.errorData(err));
+  }
   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,
+        id: channelIdMap.get(channel) ?? channel,
         label,
         type,
         messages: evts.map((m) => ({
@@ -3305,6 +4289,59 @@ var history = new Hono11().get("/turns", async (c) => {
       Connection: "keep-alive"
     }
   });
+}).get("/summaries", async (c) => {
+  const mind = c.req.query("mind") ?? "_system";
+  const period = c.req.query("period");
+  const ids = c.req.query("ids");
+  const from = c.req.query("from");
+  const to = c.req.query("to");
+  const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "50", 10) || 50, 1), 200);
+  if (ids) {
+    const db2 = await getDb();
+    const idList = ids.split(",").map((s) => parseInt(s, 10)).filter((n) => !isNaN(n));
+    if (idList.length === 0) return c.json([]);
+    const rows2 = await db2.select().from(summaries).where(inArray(summaries.id, idList));
+    const result2 = rows2.map((r) => {
+      let metadata = null;
+      if (r.metadata) {
+        try {
+          metadata = JSON.parse(r.metadata);
+        } catch (err) {
+          logger_default.debug(`malformed summary metadata for id ${r.id}`, logger_default.errorData(err));
+        }
+      }
+      return { ...r, metadata };
+    });
+    return c.json(result2);
+  }
+  if (!period || !["turn", "hour", "day", "week", "month"].includes(period)) {
+    return c.json({ error: "period is required (turn, hour, day, week, month)" }, 400);
+  }
+  const db = await getDb();
+  const conditions = [eq5(summaries.mind, mind), eq5(summaries.period, period)];
+  if (from) conditions.push(gte2(summaries.period_key, from));
+  if (to) conditions.push(sql2`${summaries.period_key} <= ${to}`);
+  const rows = await db.select({
+    id: summaries.id,
+    mind: summaries.mind,
+    period: summaries.period,
+    period_key: summaries.period_key,
+    content: summaries.content,
+    metadata: summaries.metadata,
+    created_at: summaries.created_at
+  }).from(summaries).where(and4(...conditions)).orderBy(desc3(summaries.period_key)).limit(limit);
+  const result = rows.map((r) => {
+    let metadata = null;
+    if (r.metadata) {
+      try {
+        metadata = JSON.parse(r.metadata);
+      } catch (err) {
+        logger_default.debug(`malformed meta_summary metadata for id ${r.id}`, logger_default.errorData(err));
+      }
+    }
+    return { ...r, metadata };
+  });
+  return c.json(result);
 });
 var history_default = history;
 
@@ -3313,19 +4350,19 @@ 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 { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { resolve as resolve8 } from "path";
 function generateIdentity(mindDir2) {
   const identityDir = resolve8(mindDir2, ".mind/identity");
-  mkdirSync4(identityDir, { recursive: true });
+  mkdirSync5(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 });
+  writeFileSync5(privatePath, privateKey, { mode: 384 });
+  writeFileSync5(publicPath, publicKey, { mode: 420 });
   const config2 = readVoluteConfig(mindDir2) ?? {};
   config2.identity = {
     privateKey: ".mind/identity/private.pem",
@@ -3449,7 +4486,7 @@ 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);
-  const dir = mindDir(name);
+  const dir = entry.dir ?? mindDir(name);
   const skills = await listMindSkills(dir);
   return c.json(skills);
 }).post(
@@ -3461,7 +4498,7 @@ var app12 = new Hono14().get("/:name/skills", async (c) => {
     const entry = await findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
     const { skillId } = c.req.valid("json");
-    const dir = mindDir(name);
+    const dir = entry.dir ?? mindDir(name);
     try {
       const result = await installSkill(name, dir, skillId);
       return c.json({ ok: true, ...result });
@@ -3479,7 +4516,7 @@ var app12 = new Hono14().get("/:name/skills", async (c) => {
     const entry = await findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
     const { skillId } = c.req.valid("json");
-    const dir = mindDir(name);
+    const dir = entry.dir ?? mindDir(name);
     try {
       const result = await updateSkill(name, dir, skillId);
       return c.json(result);
@@ -3497,7 +4534,7 @@ var app12 = new Hono14().get("/:name/skills", async (c) => {
     const entry = await findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
     const { skillId } = c.req.valid("json");
-    const dir = mindDir(name);
+    const dir = entry.dir ?? mindDir(name);
     try {
       const skill = await publishSkill(name, dir, skillId);
       return c.json(skill);
@@ -3511,7 +4548,7 @@ var app12 = new Hono14().get("/:name/skills", async (c) => {
   const skillName = c.req.param("skill");
   const entry = await findMind(name);
   if (!entry) return c.json({ error: "Mind not found" }, 404);
-  const dir = mindDir(name);
+  const dir = entry.dir ?? mindDir(name);
   try {
     await uninstallSkill(name, dir, skillName);
   } catch (e) {
@@ -3526,11 +4563,11 @@ var mind_skills_default = app12;
 import {
   cpSync,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync2,
   readFileSync as readFileSync10,
-  rmSync as rmSync4,
-  writeFileSync as writeFileSync7
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync8
 } from "fs";
 import { resolve as resolve12 } from "path";
 import { zValidator as zValidator5 } from "@hono/zod-validator";
@@ -3539,7 +4576,7 @@ import { Hono as Hono15 } from "hono";
 import { z as z5 } from "zod";
 
 // src/lib/consolidate.ts
-import { readdirSync, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { readdirSync, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve10 } from "path";
 async function consolidateMemory(mindDir2) {
   const soulPath = resolve10(mindDir2, "home/SOUL.md");
@@ -3601,7 +4638,7 @@ ${content2}`);
   const data = await res.json();
   const content = data.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("").trim();
   if (content) {
-    writeFileSync5(memoryPath, `${content}
+    writeFileSync6(memoryPath, `${content}
 `);
     console.log("MEMORY.md created successfully.");
   } else {
@@ -3611,7 +4648,7 @@ ${content2}`);
 
 // src/lib/convert-session.ts
 import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
 import { homedir } from "os";
 import { resolve as resolve11 } from "path";
 function convertSession(opts) {
@@ -3717,321 +4754,70 @@ function convertSession(opts) {
         isSidechain: false,
         userType: "external",
         type: "user",
-        sourceToolAssistantUUID: lastSdkUuid ?? void 0,
-        toolUseResult: "imported",
-        message: {
-          role: "user",
-          content: toolResults
-        }
-      };
-      sdkEvents.push(JSON.stringify(sdkEvent));
-      lastSdkUuid = uuid;
-    }
-  }
-  const projectId = opts.projectDir.replace(/\//g, "-");
-  const sdkDir = resolve11(homedir(), ".claude", "projects", projectId);
-  mkdirSync5(sdkDir, { recursive: true });
-  const sdkPath = resolve11(sdkDir, `${sessionId}.jsonl`);
-  writeFileSync6(sdkPath, `${sdkEvents.join("\n")}
-`);
-  console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
-  return sessionId;
-}
-var MODEL_MAP = {
-  "claude-opus-4-5": "claude-opus-4-5-20251101",
-  "claude-sonnet-4": "claude-sonnet-4-20250514"
-};
-function mapModel(model) {
-  if (!model) return "claude-opus-4-5-20251101";
-  return MODEL_MAP[model] ?? model;
-}
-function mapStopReason(stopReason) {
-  if (!stopReason) return "end_turn";
-  const map = {
-    toolUse: "tool_use",
-    endTurn: "end_turn",
-    stop: "end_turn",
-    maxTokens: "max_tokens"
-  };
-  return map[stopReason] ?? stopReason;
-}
-function mapUsage(usage) {
-  if (!usage) return { input_tokens: 0, output_tokens: 0 };
-  return {
-    input_tokens: usage.input ?? usage.input_tokens ?? 0,
-    output_tokens: usage.output ?? usage.output_tokens ?? 0,
-    cache_read_input_tokens: usage.cacheRead ?? usage.cache_read_input_tokens ?? 0,
-    cache_creation_input_tokens: usage.cacheWrite ?? usage.cache_creation_input_tokens ?? 0
-  };
-}
-function convertAssistantContent(content) {
-  const result = [];
-  for (const block of content) {
-    if (block.type === "thinking") {
-    } else if (block.type === "toolCall") {
-      result.push({
-        type: "tool_use",
-        id: block.id,
-        name: block.name,
-        input: block.arguments ?? block.input ?? {},
-        caller: { type: "direct" }
-      });
-    } else {
-      result.push(block);
-    }
-  }
-  return result;
-}
-
-// src/lib/daemon/turn-summarizer.ts
-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) {
-  if (input && typeof input === "object") {
-    const args = input;
-    const val = args.path ?? args.command ?? args.query ?? args.url;
-    if (typeof val === "string") {
-      const brief = val.length > 60 ? `${val.slice(0, 57)}...` : val;
-      return `[${name} ${brief}]`;
-    }
-  }
-  return `[${name}]`;
-}
-
-// src/lib/daemon/turn-summarizer.ts
-var sLog = logger_default.child("turn-summarizer");
-async function gatherTurnEvents(mind, session, doneId) {
-  const db = await getDb();
-  const conditions = [
-    eq5(mindHistory.mind, mind),
-    eq5(mindHistory.type, "done"),
-    lt3(mindHistory.id, doneId)
-  ];
-  if (session) {
-    conditions.push(eq5(mindHistory.session, session));
-  }
-  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 = [
-    eq5(mindHistory.mind, mind),
-    gt(mindHistory.id, prevDoneId),
-    sql2`${mindHistory.id} <= ${doneId}`
-  ];
-  if (session) {
-    turnConditions.push(eq5(mindHistory.session, session));
-  }
-  const events = await db.select({
-    id: mindHistory.id,
-    type: mindHistory.type,
-    channel: mindHistory.channel,
-    session: mindHistory.session,
-    content: mindHistory.content,
-    metadata: mindHistory.metadata,
-    created_at: mindHistory.created_at
-  }).from(mindHistory).where(and4(...turnConditions)).orderBy(mindHistory.id);
-  return {
-    events,
-    fromId: events.length > 0 ? events[0].id : doneId,
-    toId: doneId
-  };
-}
-function buildDeterministicSummary(events) {
-  const channels = /* @__PURE__ */ new Set();
-  const tools = [];
-  let hasInbound = false;
-  let hasOutbound = false;
-  for (const ev of events) {
-    if (ev.type === "inbound") {
-      hasInbound = true;
-      if (ev.channel) channels.add(ev.channel);
-    }
-    if (ev.type === "outbound" || ev.type === "text") {
-      hasOutbound = true;
-    }
-    if (ev.type === "tool_use" && ev.metadata) {
-      try {
-        const meta = JSON.parse(ev.metadata);
-        if (meta.name) tools.push(meta.name);
-      } catch (err) {
-        sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
-      }
-    }
-  }
-  const parts = [];
-  if (hasInbound) {
-    const channelList = [...channels];
-    parts.push(
-      channelList.length > 0 ? `Received message on ${channelList.join(", ")}` : "Received message"
-    );
-  }
-  if (tools.length > 0) {
-    const unique = [...new Set(tools)];
-    parts.push(`Used ${unique.join(", ")}`);
-  }
-  if (hasOutbound) {
-    parts.push("Sent response");
-  }
-  return parts.length > 0 ? `${parts.join(". ")}.` : "Turn completed.";
-}
-function buildTranscript(events) {
-  const lines = [];
-  for (const ev of events) {
-    switch (ev.type) {
-      case "inbound":
-        lines.push(`[inbound${ev.channel ? ` ${ev.channel}` : ""}] ${ev.content ?? ""}`);
-        break;
-      case "outbound":
-      case "text":
-        lines.push(`[response] ${(ev.content ?? "").slice(0, 500)}`);
-        break;
-      case "tool_use": {
-        let toolInfo = "tool";
-        if (ev.metadata) {
-          try {
-            const meta = JSON.parse(ev.metadata);
-            toolInfo = summarizeTool(meta.name ?? "tool", meta.input ?? {});
-          } catch (err) {
-            sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
-          }
-        }
-        lines.push(toolInfo);
-        break;
-      }
-      case "tool_result": {
-        const content = ev.content ?? "";
-        let isError = false;
-        if (ev.metadata) {
-          try {
-            const meta = JSON.parse(ev.metadata);
-            isError = !!meta.is_error;
-          } catch (err) {
-            sLog.debug(
-              `failed to parse tool_result metadata for event ${ev.id}`,
-              logger_default.errorData(err)
-            );
-          }
+        sourceToolAssistantUUID: lastSdkUuid ?? void 0,
+        toolUseResult: "imported",
+        message: {
+          role: "user",
+          content: toolResults
         }
-        lines.push(isError ? "[result error]" : `[result] ${content.slice(0, 200)}`);
-        break;
-      }
-      case "thinking":
-        lines.push(`[thinking] ${(ev.content ?? "").slice(0, 300)}`);
-        break;
+      };
+      sdkEvents.push(JSON.stringify(sdkEvent));
+      lastSdkUuid = uuid;
     }
   }
-  return lines.join("\n");
+  const projectId = opts.projectDir.replace(/\//g, "-");
+  const sdkDir = resolve11(homedir(), ".claude", "projects", projectId);
+  mkdirSync6(sdkDir, { recursive: true });
+  const sdkPath = resolve11(sdkDir, `${sessionId}.jsonl`);
+  writeFileSync7(sdkPath, `${sdkEvents.join("\n")}
+`);
+  console.log(`Converted ${sdkEvents.length} messages \u2192 ${sdkPath}`);
+  return sessionId;
 }
-async function gatherTurnEventsByTurnId(turnId) {
-  const db = await getDb();
-  const events = await db.select({
-    id: mindHistory.id,
-    type: mindHistory.type,
-    channel: mindHistory.channel,
-    session: mindHistory.session,
-    content: mindHistory.content,
-    metadata: mindHistory.metadata,
-    created_at: mindHistory.created_at
-  }).from(mindHistory).where(eq5(mindHistory.turn_id, turnId)).orderBy(mindHistory.id);
+var MODEL_MAP = {
+  "claude-opus-4-5": "claude-opus-4-5-20251101",
+  "claude-sonnet-4": "claude-sonnet-4-20250514"
+};
+function mapModel(model) {
+  if (!model) return "claude-opus-4-5-20251101";
+  return MODEL_MAP[model] ?? model;
+}
+function mapStopReason(stopReason) {
+  if (!stopReason) return "end_turn";
+  const map = {
+    toolUse: "tool_use",
+    endTurn: "end_turn",
+    stop: "end_turn",
+    maxTokens: "max_tokens"
+  };
+  return map[stopReason] ?? stopReason;
+}
+function mapUsage(usage) {
+  if (!usage) return { input_tokens: 0, output_tokens: 0 };
   return {
-    events,
-    fromId: events.length > 0 ? events[0].id : 0,
-    toId: events.length > 0 ? events[events.length - 1].id : 0
+    input_tokens: usage.input ?? usage.input_tokens ?? 0,
+    output_tokens: usage.output ?? usage.output_tokens ?? 0,
+    cache_read_input_tokens: usage.cacheRead ?? usage.cache_read_input_tokens ?? 0,
+    cache_creation_input_tokens: usage.cacheWrite ?? usage.cache_creation_input_tokens ?? 0
   };
 }
-async function summarizeTurn(mind, session, channel, doneId, turnId) {
-  const { events, fromId, toId } = turnId ? await gatherTurnEventsByTurnId(turnId) : await gatherTurnEvents(mind, session, doneId);
-  if (events.length === 0) return;
-  const substantiveTypes = /* @__PURE__ */ new Set(["text", "outbound", "tool_use", "tool_result", "thinking"]);
-  const hasSubstantiveOutput = events.some((ev) => substantiveTypes.has(ev.type));
-  if (!hasSubstantiveOutput) {
-    sLog.info(
-      `skipping summary for interrupted turn ${turnId ?? "(no turn)"} (no substantive output)`
-    );
-    if (turnId) {
-      try {
-        const db2 = await getDb();
-        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));
-      }
-    }
-    return;
-  }
-  const tools = [];
-  for (const ev of events) {
-    if (ev.type === "tool_use" && ev.metadata) {
-      try {
-        const meta = JSON.parse(ev.metadata);
-        if (meta.name) tools.push(meta.name);
-      } catch (err) {
-        sLog.debug(`failed to parse tool_use metadata for event ${ev.id}`, logger_default.errorData(err));
-      }
-    }
-  }
-  const fromTime = events[0].created_at;
-  const toTime = events[events.length - 1].created_at;
-  let summaryText;
-  let deterministic;
-  const transcript = buildTranscript(events);
-  if (transcript.trim()) {
-    const summaryPrompt = await getPrompt("turn_summary");
-    const aiResult = await aiCompleteUtility(summaryPrompt, transcript);
-    if (aiResult) {
-      summaryText = aiResult;
-      deterministic = false;
+function convertAssistantContent(content) {
+  const result = [];
+  for (const block of content) {
+    if (block.type === "thinking") {
+    } else if (block.type === "toolCall") {
+      result.push({
+        type: "tool_use",
+        id: block.id,
+        name: block.name,
+        input: block.arguments ?? block.input ?? {},
+        caller: { type: "direct" }
+      });
     } else {
-      summaryText = buildDeterministicSummary(events);
-      deterministic = true;
+      result.push(block);
     }
-  } else {
-    summaryText = buildDeterministicSummary(events);
-    deterministic = true;
-  }
-  const metadata = {
-    deterministic,
-    tool_count: tools.length,
-    tools: [...new Set(tools)],
-    from_id: fromId,
-    to_id: toId,
-    from_time: fromTime,
-    to_time: toTime
-  };
-  const db = await getDb();
-  let summaryId;
-  try {
-    const result = await db.insert(mindHistory).values({
-      mind,
-      type: "summary",
-      session: session ?? null,
-      channel: channel ?? null,
-      content: summaryText,
-      metadata: JSON.stringify(metadata),
-      turn_id: turnId ?? null
-    }).returning({ id: mindHistory.id });
-    summaryId = result[0]?.id;
-  } catch (err) {
-    sLog.error(
-      `failed to persist summary for ${mind} (events ${fromId}-${toId})`,
-      logger_default.errorData(err)
-    );
-    return;
-  }
-  if (turnId && summaryId != null) {
-    setSummaryEventId(turnId, summaryId).catch((err) => {
-      sLog.error(`failed to link summary to turn ${turnId}`, logger_default.errorData(err));
-    });
   }
-  publish2(mind, {
-    mind,
-    type: "summary",
-    session,
-    channel,
-    content: summaryText,
-    metadata,
-    turnId
-  });
+  return result;
 }
 
 // src/lib/health.ts
@@ -4049,7 +4835,7 @@ async function checkHealth(port) {
 }
 
 // src/lib/variant-cleanup.ts
-import { existsSync as existsSync8, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync8, rmSync as rmSync4 } from "fs";
 async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
   if (opts?.stop) {
     try {
@@ -4058,14 +4844,14 @@ async function cleanupVariant(variantName, projectRoot, variantPath, opts) {
       logger_default.warn(`failed to stop variant ${variantName}`, logger_default.errorData(err));
     }
   }
-  const { findMind: findMind2 } = await import("./registry-PJ4S5PHQ.js");
+  const { findMind: findMind2 } = await import("./registry-UYV5S6QT.js");
   const variantEntry = await findMind2(variantName);
   const branchName = variantEntry?.branch ?? variantName;
   if (existsSync8(variantPath)) {
     try {
       await gitExec(["worktree", "remove", "--force", variantPath], { cwd: projectRoot });
     } catch {
-      rmSync3(variantPath, { recursive: true, force: true });
+      rmSync4(variantPath, { recursive: true, force: true });
       try {
         await gitExec(["worktree", "prune"], { cwd: projectRoot });
       } catch (err) {
@@ -4112,7 +4898,7 @@ async function getMindStatus(name, port) {
   const manager = getMindManager();
   let status = "stopped";
   try {
-    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
+    const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
     if (getSleepManagerIfReady2()?.isSleeping(name)) {
       status = "sleeping";
     }
@@ -4170,7 +4956,7 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
   } catch {
   }
   if (existsSync9(tempWorktree)) {
-    rmSync4(tempWorktree, { recursive: true, force: true });
+    rmSync5(tempWorktree, { recursive: true, force: true });
   }
   const templatesRoot = findTemplatesRoot();
   const { composedDir, manifest } = composeTemplate(templatesRoot, template);
@@ -4192,13 +4978,13 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     copyTemplateToDir(composedDir, tempWorktree, mindName, manifest);
     const initDir = resolve12(tempWorktree, ".init");
     if (existsSync9(initDir)) {
-      rmSync4(initDir, { recursive: true, force: true });
+      rmSync5(initDir, { recursive: true, force: true });
     }
     const homeDir = resolve12(tempWorktree, "home");
     if (existsSync9(homeDir)) {
       for (const entry of readdirSync2(homeDir)) {
         if (entry !== "VOLUTE.md") {
-          rmSync4(resolve12(homeDir, entry), { recursive: true, force: true });
+          rmSync5(resolve12(homeDir, entry), { recursive: true, force: true });
         }
       }
     }
@@ -4214,9 +5000,9 @@ async function updateTemplateBranch(projectRoot, template, mindName) {
     } catch {
     }
     if (existsSync9(tempWorktree)) {
-      rmSync4(tempWorktree, { recursive: true, force: true });
+      rmSync5(tempWorktree, { recursive: true, force: true });
     }
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }
 async function mergeTemplateBranch(worktreeDir) {
@@ -4316,7 +5102,7 @@ async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride,
       generateIdentity(dest);
     }
     const state = stateDir(name);
-    mkdirSync6(state, { recursive: true });
+    mkdirSync7(state, { recursive: true });
     const envJson = resolve12(tempDir, "state/env.json");
     if (existsSync9(envJson)) {
       cpSync(envJson, resolve12(state, "env.json"));
@@ -4344,20 +5130,20 @@ async function importFromFullArchive(c, tempDir, extractedMindDir, nameOverride,
         await gitExec(["commit", "-m", "import from archive"], { cwd: dest, mindName: name, env });
       } catch (err) {
         logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
-        rmSync4(resolve12(dest, ".git"), { recursive: true, force: true });
+        rmSync5(resolve12(dest, ".git"), { recursive: true, force: true });
       }
     }
     chownMindDir(dest, name);
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync9(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync9(dest)) rmSync5(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   }
 }
@@ -4395,11 +5181,11 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
     const promptsPath = resolve12(dest, "home/.config/prompts.json");
     if (!existsSync9(promptsPath)) {
       const mindPrompts = await getMindPromptDefaults();
-      writeFileSync7(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
+      writeFileSync8(promptsPath, `${JSON.stringify(mindPrompts, null, 2)}
 `);
     }
     const state = stateDir(name);
-    mkdirSync6(state, { recursive: true });
+    mkdirSync7(state, { recursive: true });
     const envJson = resolve12(tempDir, "state/env.json");
     if (existsSync9(envJson)) {
       cpSync(envJson, resolve12(state, "env.json"));
@@ -4419,7 +5205,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       await initTemplateBranch(dest, composedDir, templateManifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for imported mind ${name}`, logger_default.errorData(err));
-      rmSync4(resolve12(dest, ".git"), { recursive: true, force: true });
+      rmSync5(resolve12(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -4443,7 +5229,7 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
     publishPublicKey(name, publicKeyPem).catch(
       (err) => logger_default.warn(`failed to publish key for ${name}`, { error: err.message })
     );
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({
       ok: true,
       name,
@@ -4454,16 +5240,16 @@ async function importFromHomeOnlyArchive(c, tempDir, extractedMindDir, nameOverr
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync9(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync9(dest)) rmSync5(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch (cleanupErr) {
       logger_default.error(`Failed to clean up registry for ${name}`, logger_default.errorData(cleanupErr));
     }
-    rmSync4(tempDir, { recursive: true, force: true });
+    rmSync5(tempDir, { recursive: true, force: true });
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }
 async function importHistoryFromArchive(name, tempDir) {
@@ -4511,7 +5297,7 @@ function importSessionsFromArchive(dest, tempDir) {
   if (!existsSync9(sessionsDir)) return;
   try {
     const destSessions = resolve12(dest, ".mind/sessions");
-    mkdirSync6(destSessions, { recursive: true });
+    mkdirSync7(destSessions, { recursive: true });
     for (const file of readdirSync2(sessionsDir)) {
       cpSync(resolve12(sessionsDir, file), resolve12(destSessions, file));
     }
@@ -4556,19 +5342,21 @@ var app13 = new Hono15().post("/", requireAdminOrSystem, zValidator5("json", cre
     applyInitFiles(dest);
     const { publicKeyPem } = generateIdentity(dest);
     {
+      const { readGlobalConfig: readGlobal } = await import("./setup-GGMKENLN.js");
+      const mindDefaults = readGlobal().mindDefaults;
       const config2 = readVoluteConfig(dest);
       if (!config2) throw new Error("Failed to read volute.json after identity generation");
       if (body.description) {
         config2.profile = { ...config2.profile, description: body.description };
       }
       if (!config2.sleep) {
-        config2.sleep = {
+        config2.sleep = mindDefaults?.sleep ?? {
           enabled: true,
           schedule: { sleep: "0 0 * * *", wake: "0 8 * * *" }
         };
       }
       if (!config2.schedules || config2.schedules.length === 0) {
-        config2.schedules = [
+        config2.schedules = mindDefaults?.schedules ?? [
           {
             id: "heartbeat",
             cron: "0 12,16,20 * * *",
@@ -4578,17 +5366,34 @@ var app13 = new Hono15().post("/", requireAdminOrSystem, zValidator5("json", cre
           }
         ];
       }
+      const cog = mindDefaults?.cognition;
+      if (cog) {
+        if (cog.thinkingLevel != null && !config2.thinkingLevel)
+          config2.thinkingLevel = cog.thinkingLevel;
+        if (cog.maxThinkingTokens != null && config2.maxThinkingTokens == null)
+          config2.maxThinkingTokens = cog.maxThinkingTokens;
+        if (cog.tokenBudget != null && config2.tokenBudget == null)
+          config2.tokenBudget = cog.tokenBudget;
+        if (cog.tokenBudgetPeriodMinutes != null && config2.tokenBudgetPeriodMinutes == null)
+          config2.tokenBudgetPeriodMinutes = cog.tokenBudgetPeriodMinutes;
+      }
       writeVoluteConfig(dest, config2);
-    }
-    if (body.model) {
-      const configPath = resolve12(dest, "home/.config/config.json");
-      const existing = existsSync9(configPath) ? JSON.parse(readFileSync10(configPath, "utf-8")) : {};
-      existing.model = template === "pi" ? qualifyModelId(body.model) : unqualifyModelId(body.model);
-      writeFileSync7(configPath, `${JSON.stringify(existing, null, 2)}
+      const modelId = body.model ?? cog?.model;
+      const sdkConfigPath = resolve12(dest, "home/.config/config.json");
+      if (modelId || cog?.compaction) {
+        const existing = existsSync9(sdkConfigPath) ? JSON.parse(readFileSync10(sdkConfigPath, "utf-8")) : {};
+        if (modelId) {
+          existing.model = template === "pi" ? qualifyModelId(modelId) : unqualifyModelId(modelId);
+        }
+        if (cog?.compaction && !existing.compaction) {
+          existing.compaction = cog.compaction;
+        }
+        writeFileSync8(sdkConfigPath, `${JSON.stringify(existing, null, 2)}
 `);
+      }
     }
     const mindPrompts = await getMindPromptDefaults();
-    writeFileSync7(
+    writeFileSync8(
       resolve12(dest, "home/.config/prompts.json"),
       `${JSON.stringify(mindPrompts, null, 2)}
 `
@@ -4614,7 +5419,7 @@ var app13 = new Hono15().post("/", requireAdminOrSystem, zValidator5("json", cre
       await initTemplateBranch(dest, composedDir, manifest, name, env);
     } catch (err) {
       logger_default.error(`git setup failed for ${name}`, logger_default.errorData(err));
-      rmSync4(resolve12(dest, ".git"), { recursive: true, force: true });
+      rmSync5(resolve12(dest, ".git"), { recursive: true, force: true });
       gitWarning = "Git setup failed \u2014 variants and upgrades won't be available until git is initialized.";
     }
     try {
@@ -4629,11 +5434,11 @@ The human who planted you described you as: "${body.description}"
 ` : "";
       const seedSoulRaw = body.seedSoul ?? await getPrompt("seed_soul", { name, description: descLine });
       const seedSoul = body.seedSoul ? substitute(seedSoulRaw, { name, description: descLine }) : seedSoulRaw;
-      writeFileSync7(resolve12(dest, "home/SOUL.md"), seedSoul);
+      writeFileSync8(resolve12(dest, "home/SOUL.md"), seedSoul);
     }
     let skillSet = body.skills ?? (body.stage === "seed" ? SEED_SKILLS : getStandardSkillsWithExtensions());
     if (body.stage === "seed" && !body.skills) {
-      const { isImagegenEnabled } = await import("./setup-TISPCO22.js");
+      const { isImagegenEnabled } = await import("./setup-GGMKENLN.js");
       if (isImagegenEnabled()) {
         skillSet = [...skillSet, "imagegen"];
       }
@@ -4651,7 +5456,7 @@ The human who planted you described you as: "${body.description}"
       try {
         const spiritEntry = await findMind("volute");
         if (spiritEntry) {
-          const { spiritDir } = await import("./spirit-VRONKFMF.js");
+          const { spiritDir } = await import("./spirit-4JP4TY4C.js");
           const sDir = spiritEntry.dir ?? spiritDir();
           const spiritConfig = readVoluteConfig(sDir) ?? {};
           const schedules = spiritConfig.schedules ?? [];
@@ -4666,7 +5471,7 @@ The human who planted you described you as: "${body.description}"
             });
             spiritConfig.schedules = schedules;
             writeVoluteConfig(sDir, spiritConfig);
-            const { getScheduler: getScheduler2 } = await import("./scheduler-ZZ7XGQG6.js");
+            const { getScheduler: getScheduler2 } = await import("./scheduler-AGG3L2FO.js");
             getScheduler2().loadSchedules("volute", sDir);
           }
         }
@@ -4677,11 +5482,11 @@ The human who planted you described you as: "${body.description}"
     if (body.stage !== "seed") {
       const customSoul = await getPromptIfCustom("default_soul");
       if (customSoul) {
-        writeFileSync7(resolve12(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
+        writeFileSync8(resolve12(dest, "home/SOUL.md"), customSoul.replace(/\{\{name\}\}/g, name));
       }
       const customMemory = await getPromptIfCustom("default_memory");
       if (customMemory) {
-        writeFileSync7(resolve12(dest, "home/MEMORY.md"), customMemory);
+        writeFileSync8(resolve12(dest, "home/MEMORY.md"), customMemory);
       }
     }
     publishPublicKey(name, publicKeyPem).catch(
@@ -4710,14 +5515,14 @@ The human who planted you described you as: "${body.description}"
       ...skillWarnings.length > 0 && { skillWarnings }
     });
   } catch (err) {
-    if (existsSync9(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync9(dest)) rmSync5(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to create mind" }, 500);
   } finally {
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }).post("/import", requireAdmin, async (c) => {
   let body;
@@ -4763,17 +5568,17 @@ ${user.trimEnd()}
     copyTemplateToDir(composedDir, dest, name, manifest);
     applyInitFiles(dest);
     const { publicKeyPem: importPublicKey } = generateIdentity(dest);
-    writeFileSync7(resolve12(dest, "home/SOUL.md"), mergedSoul);
+    writeFileSync8(resolve12(dest, "home/SOUL.md"), mergedSoul);
     const wsMemoryPath = resolve12(wsDir, "MEMORY.md");
     const hasMemory = existsSync9(wsMemoryPath);
     if (hasMemory) {
       const existingMemory = readFileSync10(wsMemoryPath, "utf-8");
-      writeFileSync7(
+      writeFileSync8(
         resolve12(dest, "home/MEMORY.md"),
         `${existingMemory.trimEnd()}${mergedMemoryExtra}`
       );
     } else if (user) {
-      writeFileSync7(resolve12(dest, "home/MEMORY.md"), `${user.trimEnd()}
+      writeFileSync8(resolve12(dest, "home/MEMORY.md"), `${user.trimEnd()}
 `);
     }
     const wsMemoryDir = resolve12(wsDir, "memory");
@@ -4813,8 +5618,8 @@ ${user.trimEnd()}
       } else if (template === "claude") {
         const sessionId = convertSession({ sessionPath: sessionFile, projectDir: dest });
         const mindRuntimeDir = resolve12(dest, ".mind");
-        mkdirSync6(mindRuntimeDir, { recursive: true });
-        writeFileSync7(resolve12(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
+        mkdirSync7(mindRuntimeDir, { recursive: true });
+        writeFileSync8(resolve12(mindRuntimeDir, "session.json"), JSON.stringify({ sessionId }));
       }
     }
     importOpenClawConnectors(name, dest);
@@ -4829,14 +5634,14 @@ ${user.trimEnd()}
     );
     return c.json({ ok: true, name, port, message: `Imported mind: ${name} (port ${port})` });
   } catch (err) {
-    if (existsSync9(dest)) rmSync4(dest, { recursive: true, force: true });
+    if (existsSync9(dest)) rmSync5(dest, { recursive: true, force: true });
     try {
       await removeMind(name);
     } catch {
     }
     return c.json({ error: err instanceof Error ? err.message : "Failed to import mind" }, 500);
   } finally {
-    rmSync4(composedDir, { recursive: true, force: true });
+    rmSync5(composedDir, { recursive: true, force: true });
   }
 }).get("/", async (c) => {
   const entries = await readRegistry();
@@ -4884,6 +5689,32 @@ ${user.trimEnd()}
   );
   const hasPages = existsSync9(resolve12(mindDir(name), "home", "public", "pages"));
   return c.json({ ...entry, ...mindStatus, variants: variantStatuses, hasPages });
+}).get("/:name/context", async (c) => {
+  const name = c.req.param("name");
+  const entry = await findMind(name);
+  if (!entry) return c.json({ error: "Mind not found" }, 404);
+  if (!getMindManager().isRunning(name)) {
+    return c.json({ error: "Mind is not running" }, 503);
+  }
+  try {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/context`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) {
+      const status = res.status >= 500 ? 502 : 404;
+      return c.json(
+        {
+          error: res.status >= 500 ? "Mind context handler errored" : "Context endpoint not available"
+        },
+        status
+      );
+    }
+    const data = await res.json();
+    return c.json(data);
+  } catch (err) {
+    console.error(`context proxy for ${name}:`, err);
+    return c.json({ error: "Failed to reach mind" }, 503);
+  }
 }).post("/:name/start", requireSelf(), async (c) => {
   const name = c.req.param("name");
   const entry = await findMind(name);
@@ -4929,7 +5760,7 @@ ${user.trimEnd()}
   const manager = getMindManager();
   try {
     if (context?.type === "reload") {
-      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
+      const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
       const sleepState = getSleepManagerIfReady2()?.getState(name);
       if (sleepState?.sleeping) {
         logger_default.info(`skipping reload for ${name} during sleep \u2014 will apply on next wake`);
@@ -5025,7 +5856,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-JTXSN7NV.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   return c.json(sm.getState(name));
@@ -5033,7 +5864,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-JTXSN7NV.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.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);
@@ -5053,7 +5884,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-JTXSN7NV.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const sleepState = sm.getState(name);
@@ -5068,7 +5899,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-JTXSN7NV.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
   const sm = getSleepManagerIfReady2();
   if (!sm) return c.json({ error: "Sleep manager not initialized" }, 503);
   const flushed = await sm.flushQueuedMessages(name);
@@ -5086,8 +5917,8 @@ ${user.trimEnd()}
   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);
+  const { syncMindProfile: syncMindProfile2 } = await import("./auth-ZFZXJZDQ.js");
+  await syncMindProfile2(name, profile);
   broadcast({ type: "profile_updated", mind: name, summary: `${name} profile updated` });
   return c.json({ ok: true });
 }).get("/:name/seed-check", requireSelf(), async (c) => {
@@ -5133,7 +5964,7 @@ ${user.trimEnd()}
   const config2 = readVoluteConfig(dir);
   const displayNameSet = !!config2?.profile?.displayName;
   const avatarSet = !!config2?.profile?.avatar;
-  const { isImagegenEnabled } = await import("./setup-TISPCO22.js");
+  const { isImagegenEnabled } = await import("./setup-GGMKENLN.js");
   const imagegenEnabled = isImagegenEnabled();
   const done = [];
   const remaining = [];
@@ -5171,7 +6002,7 @@ ${user.trimEnd()}
   try {
     const spiritEntry = await findMind("volute");
     if (spiritEntry) {
-      const { spiritDir } = await import("./spirit-VRONKFMF.js");
+      const { spiritDir } = await import("./spirit-4JP4TY4C.js");
       const sDir = spiritEntry.dir ?? spiritDir();
       const spiritConfig = readVoluteConfig(sDir);
       if (spiritConfig?.schedules) {
@@ -5179,7 +6010,7 @@ ${user.trimEnd()}
         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");
+        const { getScheduler: getScheduler2 } = await import("./scheduler-AGG3L2FO.js");
         getScheduler2().loadSchedules("volute", sDir);
       }
     }
@@ -5212,10 +6043,10 @@ ${user.trimEnd()}
   await deleteMindUser2(name);
   const state = stateDir(name);
   if (existsSync9(state)) {
-    rmSync4(state, { recursive: true, force: true });
+    rmSync5(state, { recursive: true, force: true });
   }
   if (force && existsSync9(dir)) {
-    rmSync4(dir, { recursive: true, force: true });
+    rmSync5(dir, { recursive: true, force: true });
     deleteMindUser(name);
   }
   fireWebhook({
@@ -5363,7 +6194,7 @@ ${user.trimEnd()}
       await gitExec(["commit", "-m", "initial commit"], { cwd: dir, mindName, env });
       chownMindDir(dir, mindName);
     } catch (err) {
-      rmSync4(resolve12(dir, ".git"), { recursive: true, force: true });
+      rmSync5(resolve12(dir, ".git"), { recursive: true, force: true });
       return c.json(
         {
           error: `Git initialization failed: ${err instanceof Error ? err.message : String(err)}`
@@ -5390,7 +6221,7 @@ ${user.trimEnd()}
   await updateTemplateBranch(dir, template, mindName);
   const parentDir = resolve12(dir, ".variants");
   if (!existsSync9(parentDir)) {
-    mkdirSync6(parentDir, { recursive: true });
+    mkdirSync7(parentDir, { recursive: true });
   }
   await gitExec(["worktree", "add", "-b", UPGRADE_BRANCH, worktreeDir], { cwd: dir });
   await gitExec(["rm", "-r", "--cached", "--ignore-unmatch", "home/"], {
@@ -5517,7 +6348,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 dir = mindDir(name);
+  const dir = entry.dir ?? mindDir(name);
   if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
   let config2 = readVoluteConfig(dir);
   if (!config2 && entry.template === "pi") {
@@ -5529,6 +6360,14 @@ ${user.trimEnd()}
       }
     }
   }
+  let templateConfig = {};
+  const configJsonPath = resolve12(dir, "home/.config/config.json");
+  if (existsSync9(configJsonPath)) {
+    try {
+      templateConfig = JSON.parse(readFileSync10(configJsonPath, "utf-8"));
+    } catch {
+    }
+  }
   return c.json({
     registry: {
       name: entry.name,
@@ -5538,10 +6377,26 @@ ${user.trimEnd()}
       template: entry.template
     },
     config: {
-      model: config2?.model ?? null,
-      thinkingLevel: config2?.thinkingLevel ?? null,
+      model: config2?.model ?? templateConfig.model ?? null,
+      thinkingLevel: (() => {
+        if (config2?.thinkingLevel) return config2.thinkingLevel;
+        const tc = templateConfig;
+        if (tc.thinkingLevel) return tc.thinkingLevel;
+        if (tc.reasoningEffort) return tc.reasoningEffort;
+        const mtt = tc.maxThinkingTokens;
+        if (mtt) {
+          if (mtt <= 1024) return "minimal";
+          if (mtt <= 4096) return "low";
+          if (mtt <= 1e4) return "medium";
+          if (mtt <= 32e3) return "high";
+          return "xhigh";
+        }
+        return null;
+      })(),
+      maxThinkingTokens: config2?.maxThinkingTokens ?? templateConfig.maxThinkingTokens ?? null,
       tokenBudget: config2?.tokenBudget ?? null,
-      tokenBudgetPeriodMinutes: config2?.tokenBudgetPeriodMinutes ?? null
+      tokenBudgetPeriodMinutes: config2?.tokenBudgetPeriodMinutes ?? null,
+      compaction: templateConfig.compaction ?? null
     }
   });
 }).put(
@@ -5552,15 +6407,17 @@ ${user.trimEnd()}
     z5.object({
       model: z5.string().optional(),
       thinkingLevel: z5.enum(["off", "minimal", "low", "medium", "high", "xhigh"]).optional(),
+      maxThinkingTokens: z5.number().int().positive().nullable().optional(),
       tokenBudget: z5.number().int().positive().nullable().optional(),
-      tokenBudgetPeriodMinutes: z5.number().int().positive().nullable().optional()
+      tokenBudgetPeriodMinutes: z5.number().int().positive().nullable().optional(),
+      compaction: z5.object({ maxContextTokens: z5.number().int().positive().nullable().optional() }).nullable().optional()
     })
   ),
   async (c) => {
     const name = c.req.param("name");
     const entry = await findMind(name);
     if (!entry) return c.json({ error: "Mind not found" }, 404);
-    const dir = mindDir(name);
+    const dir = entry.dir ?? mindDir(name);
     if (!existsSync9(dir)) return c.json({ error: "Mind directory missing" }, 404);
     const body = c.req.valid("json");
     const existing = readVoluteConfig(dir) ?? {};
@@ -5582,7 +6439,96 @@ ${user.trimEnd()}
         existing.tokenBudgetPeriodMinutes = body.tokenBudgetPeriodMinutes;
       }
     }
+    if (body.maxThinkingTokens !== void 0) {
+      if (body.maxThinkingTokens === null) {
+        delete existing.maxThinkingTokens;
+      } else {
+        existing.maxThinkingTokens = body.maxThinkingTokens;
+      }
+    }
     writeVoluteConfig(dir, existing);
+    const needsConfigJson = body.model !== void 0 || body.thinkingLevel !== void 0 || body.maxThinkingTokens !== void 0 || body.compaction !== void 0;
+    if (needsConfigJson) {
+      const configJsonPath = resolve12(dir, "home/.config/config.json");
+      let templateConfig = {};
+      if (existsSync9(configJsonPath)) {
+        try {
+          templateConfig = JSON.parse(readFileSync10(configJsonPath, "utf-8"));
+        } catch {
+        }
+      }
+      if (body.model !== void 0) {
+        templateConfig.model = body.model;
+      }
+      const tmpl = entry.template ?? "claude";
+      if (body.thinkingLevel !== void 0) {
+        if (tmpl === "claude") {
+          const claudeThinkingTokens = {
+            off: null,
+            minimal: 1024,
+            low: 4096,
+            medium: 1e4,
+            high: 32e3,
+            xhigh: 128e3
+          };
+          const tokens = claudeThinkingTokens[body.thinkingLevel] ?? null;
+          if (tokens === null) {
+            delete templateConfig.maxThinkingTokens;
+          } else {
+            templateConfig.maxThinkingTokens = tokens;
+          }
+        } else if (tmpl === "codex") {
+          const codexMap = {
+            off: null,
+            minimal: "minimal",
+            low: "low",
+            medium: "medium",
+            high: "high",
+            xhigh: "xhigh"
+          };
+          const effort = codexMap[body.thinkingLevel] ?? null;
+          if (effort === null) {
+            delete templateConfig.reasoningEffort;
+          } else {
+            templateConfig.reasoningEffort = effort;
+          }
+        } else {
+          templateConfig.thinkingLevel = body.thinkingLevel;
+        }
+      }
+      if (body.maxThinkingTokens !== void 0) {
+        if (body.maxThinkingTokens === null) {
+          delete templateConfig.maxThinkingTokens;
+        } else {
+          templateConfig.maxThinkingTokens = body.maxThinkingTokens;
+        }
+      }
+      if (body.compaction !== void 0) {
+        if (body.compaction === null) {
+          delete templateConfig.compaction;
+        } else {
+          const comp = templateConfig.compaction ?? {};
+          if (body.compaction.maxContextTokens === null) {
+            delete comp.maxContextTokens;
+          } else if (body.compaction.maxContextTokens !== void 0) {
+            comp.maxContextTokens = body.compaction.maxContextTokens;
+          }
+          templateConfig.compaction = comp;
+        }
+      }
+      writeFileSync8(configJsonPath, `${JSON.stringify(templateConfig, null, 2)}
+`);
+    }
+    if (entry.mindType === "spirit" && body.model !== void 0) {
+      try {
+        const { readGlobalConfig: readGlobalConfig2, writeGlobalConfig: writeGlobalConfig2 } = await import("./setup-GGMKENLN.js");
+        const globalConfig = readGlobalConfig2();
+        globalConfig.spiritModel = body.model;
+        writeGlobalConfig2(globalConfig);
+      } catch (err) {
+        logger_default.warn("failed to sync spirit model to global config", logger_default.errorData(err));
+      }
+    }
     return c.json({ ok: true });
   }
 ).get("/:name/delivery/pending", async (c) => {
@@ -5603,7 +6549,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-SBY2WG7O.js");
+  const { aiComplete: aiCompleteFn, isAiConfigured } = await import("./ai-service-PSILB5WD.js");
   if (!isAiConfigured()) {
     return c.json({ error: "AI service not configured" }, 503);
   }
@@ -5905,18 +6851,18 @@ ${user.trimEnd()}
     sinceTimestamp = new Date(Date.now() - 36e5).toISOString().replace("T", " ").slice(0, 19);
   }
   const conditions = [
-    eq6(mindHistory.mind, name),
-    eq6(mindHistory.type, "summary"),
-    sql3`${mindHistory.created_at} > ${sinceTimestamp}`
+    eq6(summaries.mind, name),
+    eq6(summaries.period, "turn"),
+    sql3`${summaries.created_at} > ${sinceTimestamp}`
   ];
   if (currentSession) {
-    conditions.push(sql3`${mindHistory.session} != ${currentSession}`);
+    conditions.push(sql3`${turns.session} != ${currentSession}`);
   }
   const rows = await db.select({
-    session: mindHistory.session,
-    content: mindHistory.content,
-    created_at: mindHistory.created_at
-  }).from(mindHistory).where(and5(...conditions)).orderBy(desc4(mindHistory.created_at)).limit(50);
+    session: turns.session,
+    content: summaries.content,
+    created_at: summaries.created_at
+  }).from(summaries).innerJoin(turns, eq6(turns.id, summaries.period_key)).where(and5(...conditions)).orderBy(desc4(summaries.created_at)).limit(50);
   if (rows.length === 0) {
     return c.json({ context: null });
   }
@@ -5944,20 +6890,64 @@ ${lines.join("\n")}` });
     conditions.push(eq6(mindHistory.session, session));
   }
   const effectivePreset = full ? "all" : preset;
+  if (!effectivePreset || effectivePreset === "summary") {
+    const sumConditions = [eq6(summaries.mind, name), eq6(summaries.period, "turn")];
+    if (session) {
+      sumConditions.push(eq6(turns.session, session));
+      const sumRows2 = await db.select({
+        id: summaries.id,
+        mind: summaries.mind,
+        period: summaries.period,
+        period_key: summaries.period_key,
+        content: summaries.content,
+        metadata: summaries.metadata,
+        created_at: summaries.created_at,
+        session: turns.session
+      }).from(summaries).innerJoin(turns, eq6(turns.id, summaries.period_key)).where(and5(...sumConditions)).orderBy(desc4(summaries.created_at)).limit(limit).offset(offset);
+      return c.json(
+        sumRows2.map((r) => ({
+          id: r.id,
+          mind: r.mind,
+          type: "summary",
+          channel: null,
+          session: r.session,
+          sender: null,
+          message_id: null,
+          content: r.content,
+          metadata: r.metadata,
+          turn_id: r.period_key,
+          created_at: r.created_at
+        }))
+      );
+    }
+    const sumRows = await db.select().from(summaries).where(and5(...sumConditions)).orderBy(desc4(summaries.created_at)).limit(limit).offset(offset);
+    return c.json(
+      sumRows.map((r) => ({
+        id: r.id,
+        mind: r.mind,
+        type: "summary",
+        channel: null,
+        session: null,
+        sender: null,
+        message_id: null,
+        content: r.content,
+        metadata: r.metadata,
+        turn_id: r.period_key,
+        created_at: r.created_at
+      }))
+    );
+  }
   switch (effectivePreset) {
     case "all":
       break;
     case "conversation":
-      conditions.push(sql3`${mindHistory.type} IN ('summary','inbound','outbound','tool_use')`);
+      conditions.push(sql3`${mindHistory.type} IN ('inbound','outbound','tool_use')`);
       break;
     case "detailed":
       conditions.push(
-        sql3`${mindHistory.type} IN ('summary','inbound','outbound','tool_use','tool_result','text','thinking')`
+        sql3`${mindHistory.type} IN ('inbound','outbound','tool_use','tool_result','text','thinking')`
       );
       break;
-    default:
-      conditions.push(sql3`${mindHistory.type} IN ('summary')`);
-      break;
   }
   const rows = await db.select().from(mindHistory).where(and5(...conditions)).orderBy(desc4(mindHistory.created_at)).limit(limit).offset(offset);
   return c.json(rows);
@@ -6132,23 +7122,20 @@ var app16 = new Hono18().get("/:name/clock/status", async (c) => {
   const sleepConfig = sleepManager?.getSleepConfig(name) ?? null;
   const schedules = readSchedules(name);
   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) {
       const fireDate = new Date(s.fireAt);
-      if (fireDate >= now && fireDate <= in24h) {
+      if (fireDate >= now) {
         upcoming.push({ id: s.id, at: fireDate.toISOString(), type: "timer" });
       }
     } else if (s.cron) {
       try {
         const interval = CronExpressionParser.parse(s.cron);
         const next = interval.next().toDate();
-        if (next <= in24h) {
-          upcoming.push({ id: s.id, at: next.toISOString(), type: "cron" });
-        }
+        upcoming.push({ id: s.id, at: next.toISOString(), type: "cron" });
       } catch {
         slog2.warn(`invalid cron "${s.cron}" for schedule "${s.id}" of ${name}`);
       }
@@ -6160,9 +7147,61 @@ var app16 = new Hono18().get("/:name/clock/status", async (c) => {
       }
     }
   }
+  if (sleepState?.sleeping) {
+    if (sleepState.scheduledWakeAt) {
+      upcoming.push({ id: "sleep", at: sleepState.scheduledWakeAt, type: "cron" });
+    }
+    if (sleepState.sleepingSince) {
+      previous.push({ id: "sleep", at: sleepState.sleepingSince });
+    }
+  } else if (sleepConfig?.enabled && sleepConfig.schedule) {
+    try {
+      const sleepInterval = CronExpressionParser.parse(sleepConfig.schedule.sleep);
+      const nextSleep = sleepInterval.next().toDate();
+      upcoming.push({ id: "sleep", at: nextSleep.toISOString(), type: "cron" });
+    } catch {
+    }
+    try {
+      const prevWakeInterval = CronExpressionParser.parse(sleepConfig.schedule.wake);
+      const prevWake = prevWakeInterval.prev().toDate();
+      previous.push({ id: "sleep", at: prevWake.toISOString() });
+    } catch {
+    }
+  }
   upcoming.sort((a, b) => a.at.localeCompare(b.at));
   previous.sort((a, b) => b.at.localeCompare(a.at));
   return c.json({ sleep: sleepState, sleepConfig, schedules, upcoming, previous });
+}).get("/:name/sleep/config", async (c) => {
+  const name = c.req.param("name");
+  if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
+  const config2 = readVoluteConfig(mindDir(name));
+  return c.json(config2?.sleep ?? { enabled: false });
+}).put("/:name/sleep/config", 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();
+  if (body.schedule) {
+    for (const field of ["sleep", "wake"]) {
+      if (body.schedule[field]) {
+        try {
+          CronExpressionParser.parse(body.schedule[field]);
+        } catch {
+          return c.json({ error: `Invalid ${field} cron: ${body.schedule[field]}` }, 400);
+        }
+      }
+    }
+  }
+  const dir = mindDir(name);
+  const config2 = readVoluteConfig(dir) ?? {};
+  const sleep = config2.sleep ?? {};
+  if (body.enabled !== void 0) sleep.enabled = body.enabled;
+  if (body.schedule !== void 0) sleep.schedule = body.schedule;
+  if (body.wakeTriggers !== void 0) sleep.wakeTriggers = body.wakeTriggers;
+  config2.sleep = sleep;
+  writeVoluteConfig(dir, config2);
+  getSleepManagerIfReady()?.invalidateSleepConfig(name);
+  return c.json({ ok: true });
 }).get("/:name/schedules", async (c) => {
   const name = c.req.param("name");
   if (!await findMind(name)) return c.json({ error: "Mind not found" }, 404);
@@ -6290,7 +7329,7 @@ var app16 = new Hono18().get("/:name/clock/status", async (c) => {
   const body = await c.req.text();
   const message = `[webhook: ${event}] ${body}`;
   try {
-    const { sendSystemMessage } = await import("./system-chat-JAPOJ3KE.js");
+    const { sendSystemMessage } = await import("./system-chat-TYLOL7SX.js");
     await sendSystemMessage(name, message);
     return c.json({ ok: true });
   } catch (err) {
@@ -6301,7 +7340,7 @@ var app16 = new Hono18().get("/:name/clock/status", async (c) => {
 var schedules_default = app16;
 
 // src/web/api/setup.ts
-import { mkdirSync as mkdirSync7 } from "fs";
+import { mkdirSync as mkdirSync8 } from "fs";
 import { homedir as homedir2 } from "os";
 import { resolve as resolve14 } from "path";
 import { Hono as Hono19 } from "hono";
@@ -6311,8 +7350,8 @@ var setup = new Hono19();
 function writeSetupConfig(systemName, description) {
   const configHome = process.env.VOLUTE_HOME ?? resolve14(homedir2(), ".volute");
   const mindsDir = resolve14(configHome, "minds");
-  mkdirSync7(configHome, { recursive: true });
-  mkdirSync7(mindsDir, { recursive: true });
+  mkdirSync8(configHome, { recursive: true });
+  mkdirSync8(mindsDir, { recursive: true });
   const existingConfig = readGlobalConfig();
   const setupConfig = {
     type: "local",
@@ -6343,7 +7382,7 @@ setup.get("/status", async (c) => {
   let hasAccount = false;
   if (hasSystem) {
     try {
-      const { listUsersByType: listUsersByType2 } = await import("./auth-GKCDSO4T.js");
+      const { listUsersByType: listUsersByType2 } = await import("./auth-ZFZXJZDQ.js");
       const brains = await listUsersByType2("brain");
       hasAccount = brains.length > 0;
     } catch (err) {
@@ -6528,7 +7567,7 @@ setup.post("/account", async (c) => {
     }
   }
   try {
-    const { createUser: createUser2, updateUserProfile: updateUserProfile2 } = await import("./auth-GKCDSO4T.js");
+    const { createUser: createUser2, updateUserProfile: updateUserProfile2 } = await import("./auth-ZFZXJZDQ.js");
     const user = await createUser2(body.username.trim(), body.password);
     if (body.displayName?.trim()) {
       await updateUserProfile2(user.id, { display_name: body.displayName.trim() });
@@ -6574,7 +7613,7 @@ setup.post("/models", async (c) => {
     return c.json({ error: "Spirit model is required" }, 400);
   }
   try {
-    const { setEnabledModels: setEnabledModels3, setUtilityModel: setUtilityModel2 } = await import("./ai-service-SBY2WG7O.js");
+    const { setEnabledModels: setEnabledModels3, setUtilityModel: setUtilityModel2 } = await import("./ai-service-PSILB5WD.js");
     setEnabledModels3(body.models);
     const config2 = readGlobalConfig();
     config2.spiritModel = body.spiritModel.trim();
@@ -6592,8 +7631,8 @@ setup.post("/complete", async (c) => {
     return c.json({ error: "Setup already complete" }, 400);
   }
   try {
-    const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-VRONKFMF.js");
-    const { startSpiritFull } = await import("./mind-service-2MQ6UK5N.js");
+    const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-4JP4TY4C.js");
+    const { startSpiritFull } = await import("./mind-service-VIKZJK2M.js");
     await ensureSpiritProject();
     await syncSpiritTemplate();
     const warnings = [];
@@ -6609,8 +7648,8 @@ setup.post("/complete", async (c) => {
     }
     let spiritConversationId;
     try {
-      const { getOrCreateMindUser: getOrCreateMindUser2, listUsersByType: listUsersByType2 } = await import("./auth-GKCDSO4T.js");
-      const { createConversation: createConversation6, findDMConversation: findDMConversation2 } = await import("./conversations-AWI5SZW2.js");
+      const { getOrCreateMindUser: getOrCreateMindUser2, listUsersByType: listUsersByType2 } = await import("./auth-ZFZXJZDQ.js");
+      const { createConversation: createConversation6, findDMConversation: findDMConversation2 } = await import("./conversations-HL2JP5GI.js");
       const spiritUser = await getOrCreateMindUser2("volute");
       const brains = await listUsersByType2("brain");
       const admin2 = brains.find((u) => u.role === "admin");
@@ -6633,8 +7672,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-DFF5SJRM.js");
-        const { listUsersByType: listUsers6 } = await import("./auth-GKCDSO4T.js");
+        const { deliverMessage: deliverMessage2 } = await import("./message-delivery-V3R6NXJP.js");
+        const { listUsersByType: listUsers6 } = await import("./auth-ZFZXJZDQ.js");
         const admins = await listUsers6("brain");
         const admin2 = admins.find((u) => u.role === "admin");
         const adminName = admin2?.display_name || admin2?.username || "the admin";
@@ -6693,7 +7732,7 @@ var app17 = new Hono20().post("/:name/shared/merge", requireAdmin, async (c) =>
 var shared_default = app17;
 
 // src/web/api/skills.ts
-import { existsSync as existsSync10, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync5 } from "fs";
+import { existsSync as existsSync10, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync6 } from "fs";
 import { tmpdir } from "os";
 import { join, resolve as resolve15 } from "path";
 import AdmZip from "adm-zip";
@@ -6747,6 +7786,16 @@ var app18 = new Hono21().get("/", async (c) => {
   removed.add(skill);
   writeGlobalConfig({ ...config2, defaultSkills: updated, removedDefaultSkills: [...removed] });
   return c.json({ skills: updated });
+}).get("/auto-update", (c) => {
+  return c.json({ enabled: isAutoUpdateSkillsEnabled() });
+}).put("/auto-update", requireAdmin, async (c) => {
+  const body = await c.req.json();
+  if (typeof body.enabled !== "boolean") {
+    return c.json({ error: "body.enabled must be a boolean" }, 400);
+  }
+  const config2 = readGlobalConfig();
+  writeGlobalConfig({ ...config2, autoUpdateSkills: body.enabled });
+  return c.json({ enabled: body.enabled });
 }).post("/upload", requireAdmin, async (c) => {
   const body = await c.req.parseBody();
   const file = body.file;
@@ -6790,7 +7839,7 @@ var app18 = new Hono21().get("/", async (c) => {
     }
     throw e;
   } finally {
-    rmSync5(tmpDir, { recursive: true, force: true });
+    rmSync6(tmpDir, { recursive: true, force: true });
   }
 }).get("/:id", async (c) => {
   const id = c.req.param("id");
@@ -7113,13 +8162,13 @@ var app22 = new Hono25().use("*", authMiddleware).get("/", async (c) => {
 var events_default = app22;
 
 // src/web/api/variants.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
 import { resolve as resolve17 } from "path";
 import { Hono as Hono26 } from "hono";
 
 // src/lib/spawn-server.ts
 import { spawn as spawn4 } from "child_process";
-import { closeSync, mkdirSync as mkdirSync8, openSync, readFileSync as readFileSync11 } from "fs";
+import { closeSync, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync11 } from "fs";
 import { resolve as resolve16 } from "path";
 function tsxBin(cwd) {
   return resolve16(cwd, "node_modules", ".bin", "tsx");
@@ -7158,7 +8207,7 @@ function spawnAttached(cwd, port) {
 }
 function spawnDetached(cwd, port, logDir) {
   const logsDir = logDir ?? resolve16(cwd, ".mind", "logs");
-  mkdirSync8(logsDir, { recursive: true });
+  mkdirSync9(logsDir, { recursive: true });
   const logPath = resolve16(logsDir, "mind.log");
   const logFd = openSync(logPath, "a");
   const child = spawn4(tsxBin(cwd), ["src/server.ts", "--port", String(port)], {
@@ -7279,7 +8328,7 @@ var app23 = new Hono26().get("/:name/variants", async (c) => {
   if (existsSync11(variantDir)) {
     return c.json({ error: `Variant directory already exists: ${variantDir}` }, 409);
   }
-  mkdirSync9(resolve17(projectRoot, ".variants"), { recursive: true });
+  mkdirSync10(resolve17(projectRoot, ".variants"), { recursive: true });
   try {
     await gitExec(["worktree", "add", "-b", variantName, variantDir], { cwd: projectRoot });
   } catch (e) {
@@ -7302,7 +8351,7 @@ var app23 = new Hono26().get("/:name/variants", async (c) => {
     return c.json({ error: `npm install failed: ${msg}` }, 500);
   }
   if (body.soul) {
-    writeFileSync8(resolve17(variantDir, "home/SOUL.md"), body.soul);
+    writeFileSync9(resolve17(variantDir, "home/SOUL.md"), body.soul);
   }
   const variantPort = body.port ?? await nextPort();
   await addVariant(variantName, mindName, variantPort, variantDir, variantName);
@@ -7397,8 +8446,8 @@ var app23 = new Hono26().get("/:name/variants", async (c) => {
   await cleanupVariant(variantName, projectRoot, variantEntry.dir);
   if (variantName.endsWith("-upgrade") || variantName === "upgrade") {
     try {
-      const { computeTemplateHash: computeTemplateHash2 } = await import("./template-hash-A6VVKOXJ.js");
-      const { setMindTemplateHash: setMindTemplateHash2 } = await import("./registry-PJ4S5PHQ.js");
+      const { computeTemplateHash: computeTemplateHash2 } = await import("./template-hash-EJRTKE36.js");
+      const { setMindTemplateHash: setMindTemplateHash2 } = await import("./registry-UYV5S6QT.js");
       const tmpl = parentEntry.template ?? "claude";
       await setMindTemplateHash2(mindName, computeTemplateHash2(tmpl));
     } catch (err) {
@@ -7622,8 +8671,8 @@ async function fanOutToMinds(opts) {
   );
   const participantNames = participants.map((p) => p.username);
   const isDM = opts.isDM ?? participants.length === 2;
-  const { getMindManager: getMindManager2 } = await import("./mind-manager-NBJF5D26.js");
-  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-JTXSN7NV.js");
+  const { getMindManager: getMindManager2 } = await import("./mind-manager-MWW3BTS4.js");
+  const { getSleepManagerIfReady: getSleepManagerIfReady2 } = await import("./sleep-manager-BJK2ROPX.js");
   const manager = getMindManager2();
   const sm = getSleepManagerIfReady2();
   const targetMinds = mindParticipants.map((ap) => {
@@ -8188,25 +9237,25 @@ async function startDaemon(opts) {
   }
   const DAEMON_PID_PATH = resolve19(systemDir, "daemon.pid");
   const DAEMON_JSON_PATH = resolve19(systemDir, "daemon.json");
-  mkdirSync10(home, { recursive: true });
+  mkdirSync11(home, { recursive: true });
   ensureSystemDir();
   try {
     await ensureSharedRepo();
   } catch (err) {
     logger_default.warn("failed to initialize shared repo", logger_default.errorData(err));
   }
-  const { migrateSetupCompleted } = await import("./setup-TISPCO22.js");
+  const { migrateSetupCompleted } = await import("./setup-GGMKENLN.js");
   migrateSetupCompleted();
-  await (await import("./db-F34YLV7D.js")).getDb();
+  await (await import("./db-RYX3SS2W.js")).getDb();
   try {
     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();
+    const { users: users2 } = await import("./schema-ETMABTW4.js");
+    const db = await (await import("./db-RYX3SS2W.js")).getDb();
     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-GJOK4QLQ.js");
+  const { initSandbox } = await import("./sandbox-SI5HMBP3.js");
   await initSandbox();
   try {
     await syncBuiltinSkills();
@@ -8220,13 +9269,20 @@ async function startDaemon(opts) {
     logger_default.error("failed to load extensions", logger_default.errorData(err));
   }
   await initDefaultSkills();
+  if (isAutoUpdateSkillsEnabled()) {
+    try {
+      await autoUpdateMindSkills();
+    } catch (err) {
+      logger_default.error("failed to auto-update mind skills", logger_default.errorData(err));
+    }
+  }
   try {
     await ensureSystemChannel();
   } catch (err) {
     logger_default.warn("failed to ensure #system channel", logger_default.errorData(err));
   }
   try {
-    const { getOrCreateSystemUser: getOrCreateSystemUser2 } = await import("./auth-GKCDSO4T.js");
+    const { getOrCreateSystemUser: getOrCreateSystemUser2 } = await import("./auth-ZFZXJZDQ.js");
     await getOrCreateSystemUser2();
   } catch (err) {
     logger_default.warn(
@@ -8237,7 +9293,7 @@ async function startDaemon(opts) {
   const token = process.env.VOLUTE_DAEMON_TOKEN || randomBytes(32).toString("hex");
   let tls;
   if (opts.tailscale) {
-    const { getTailscaleTls } = await import("./tailscale-XHQBZROW.js");
+    const { getTailscaleTls } = await import("./tailscale-ZEUK7GKZ.js");
     const tlsConfig = await getTailscaleTls();
     tls = { key: tlsConfig.key, cert: tlsConfig.cert };
     logger_default.info("Tailscale HTTPS enabled", { hostname: tlsConfig.hostname });
@@ -8258,11 +9314,11 @@ async function startDaemon(opts) {
   process.env.VOLUTE_DAEMON_TOKEN = token;
   process.env.VOLUTE_DAEMON_PORT = String(daemonPort);
   process.env.VOLUTE_DAEMON_HOSTNAME = hostname;
-  writeFileSync9(DAEMON_PID_PATH, myPid, { mode: 420 });
+  writeFileSync10(DAEMON_PID_PATH, myPid, { mode: 420 });
   const daemonConfig = { port, hostname, token };
   if (internalPort) daemonConfig.internalPort = internalPort;
   if (tls) daemonConfig.tls = true;
-  writeFileSync9(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
+  writeFileSync10(DAEMON_JSON_PATH, `${JSON.stringify(daemonConfig, null, 2)}
 `, { mode: 420 });
   const delivery = initDeliveryManager();
   const manager = initMindManager();
@@ -8276,6 +9332,8 @@ async function startDaemon(opts) {
   tokenBudget.start();
   const sleepManager = initSleepManager();
   sleepManager.start();
+  const summarizer = initSummarizer();
+  summarizer.start();
   const unsubscribeWebhook = initWebhook();
   await completeOrphanedTurns();
   const allMinds = await readAllMinds();
@@ -8307,10 +9365,10 @@ async function startDaemon(opts) {
     await Promise.all(workers);
   }
   try {
-    const { isSetupComplete: isSetupComplete2 } = await import("./setup-TISPCO22.js");
+    const { isSetupComplete: isSetupComplete2 } = await import("./setup-GGMKENLN.js");
     if (isSetupComplete2()) {
-      const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-VRONKFMF.js");
-      const { startSpiritFull } = await import("./mind-service-2MQ6UK5N.js");
+      const { ensureSpiritProject, syncSpiritTemplate } = await import("./spirit-4JP4TY4C.js");
+      const { startSpiritFull } = await import("./mind-service-VIKZJK2M.js");
       await ensureSpiritProject();
       await syncSpiritTemplate();
       const spiritEntry = await findMind("volute");
@@ -8327,7 +9385,7 @@ async function startDaemon(opts) {
   bridgeManager.startBridges(daemonPort).catch((err) => {
     logger_default.warn("failed to start bridges", logger_default.errorData(err));
   });
-  import("./cloud-sync-4NWLMFVH.js").then(
+  import("./cloud-sync-TG3TIX5H.js").then(
     ({ consumeQueuedMessages }) => consumeQueuedMessages().catch((err) => {
       logger_default.warn("failed to consume queued cloud messages", logger_default.errorData(err));
     })
@@ -8335,7 +9393,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-NBI2MTJO.js");
+    const { backfillTemplateHashes, notifyVersionUpdate } = await import("./version-notify-YCH4UVQ2.js");
     backfillTemplateHashes();
     notifyVersionUpdate().catch((err) => {
       logger_default.warn("failed to send version update notifications", logger_default.errorData(err));
@@ -8393,6 +9451,7 @@ async function startDaemon(opts) {
       safe("scheduler.saveState", () => scheduler.saveState());
       safe("mailPoller.stop", () => mailPoller.stop());
       safe("tokenBudget.stop", () => tokenBudget.stop());
+      safe("summarizer.stop", () => summarizer.stop());
       safe("stopApiKeyRefresh", stopApiKeyRefresh);
       safe("delivery.dispose", () => delivery.dispose());
       await safe("bridgeManager.stopAll", () => bridgeManager.stopAll());