volute 0.25.0 → 0.27.0

package/dist/{chunk-PMX4EIJK.js → chunk-OQZH4PBB.js}

@@ -1,80 +1,105 @@
 #!/usr/bin/env node
 import {
   readSystemsConfig
-} from "./chunk-HFCBO2GL.js";
+} from "./chunk-KDGS53OS.js";
 import {
   markIdle
-} from "./chunk-E7GOKNOT.js";
+} from "./chunk-K5NAC55T.js";
 import {
-  broadcast,
-  publish,
-  subscribe
-} from "./chunk-BFK6SOEJ.js";
-import {
-  RestartTracker,
-  RotatingLog,
   clearJsonMap,
   getMindManager,
   getPrompt,
   loadJsonMap,
   saveJsonMap
-} from "./chunk-SHSWYG2J.js";
-import {
-  readVoluteConfig
-} from "./chunk-SIAG3QMM.js";
+} from "./chunk-PHSAT7YL.js";
 import {
-  loadMergedEnv
-} from "./chunk-PHU4DEAJ.js";
+  addMessage,
+  createChannel,
+  getChannelByName,
+  getParticipants,
+  joinChannel,
+  publish as publish2
+} from "./chunk-IAYBDWVG.js";
 import {
-  conversationParticipants,
-  conversationReads,
-  conversations,
-  deliveryQueue,
-  getDb,
-  messages,
-  mindHistory,
-  users
-} from "./chunk-33XAVCS4.js";
+  broadcast,
+  publish,
+  subscribe
+} from "./chunk-VIVMW2H2.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 import {
   exec
-} from "./chunk-JTDFJWI2.js";
+} from "./chunk-AW7PFDVN.js";
 import {
-  chownMindDir,
-  isIsolationEnabled,
-  wrapForIsolation
-} from "./chunk-NWPT4ASZ.js";
-import {
-  daemonLoopback,
+  deliveryQueue,
   findMind,
-  findVariant,
+  getBaseName,
+  getDb,
   mindDir,
+  mindHistory,
   readRegistry,
   stateDir,
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
+  users,
+  voluteHome,
+  voluteSystemDir
+} from "./chunk-H7OZRFJB.js";
 
 // src/lib/daemon/sleep-manager.ts
-import { execFile } from "child_process";
+import { execFile, spawn as spawnChild } from "child_process";
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
   readFileSync as readFileSync5,
   readlinkSync,
   renameSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { resolve as resolve8 } from "path";
 import { promisify } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and4, eq as eq4, inArray as inArray2 } from "drizzle-orm";
+import { and as and3, eq as eq3, inArray as inArray2 } from "drizzle-orm";
+
+// src/lib/volute-config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+function readJson(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    console.error(`[volute-config] failed to parse ${path}: ${err}`);
+    return null;
+  }
+}
+function readVoluteConfig(mindDir2) {
+  const path = resolve(mindDir2, "home/.config/volute.json");
+  const config = readJson(path);
+  if (!config) return null;
+  const legacy = config;
+  if (!config.profile && ("displayName" in config || "description" in config || "avatar" in config)) {
+    config.profile = {
+      displayName: legacy.displayName,
+      description: legacy.description,
+      avatar: legacy.avatar
+    };
+    delete legacy.displayName;
+    delete legacy.description;
+    delete legacy.avatar;
+  }
+  return config;
+}
+function writeVoluteConfig(mindDir2, config) {
+  const path = resolve(mindDir2, "home/.config/volute.json");
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
 
 // src/lib/auth.ts
 import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq } from "drizzle-orm";
+import { and, count, eq, inArray } from "drizzle-orm";
 var userSelectFields = {
   id: users.id,
   username: users.username,
@@ -132,7 +157,7 @@ async function getOrCreateMindUser(mindName) {
     const [result] = await db.insert(users).values({
       username: mindName,
       password_hash: "!mind",
-      role: "mind",
+      role: "user",
       user_type: "mind"
     }).returning(userSelectFields);
     return result;
@@ -197,10 +222,14 @@ async function syncMindProfile(mindName, config) {
   await db.update(users).set(newProfile).where(eq(users.id, user.id));
   broadcast({ type: "profile_updated", mind: mindName, summary: `${mindName} profile updated` });
 }
+async function migrateMindRoles() {
+  const db = await getDb();
+  await db.update(users).set({ role: "user" }).where(and(eq(users.user_type, "mind"), inArray(users.role, ["mind", "agent"])));
+}
 
 // src/lib/pages-watcher.ts
-import { existsSync, readdirSync, statSync, watch } from "fs";
-import { join, resolve } from "path";
+import { existsSync as existsSync2, readdirSync, statSync, watch } from "fs";
+import { join, resolve as resolve2 } from "path";
 var watchers = /* @__PURE__ */ new Map();
 var homeWatchers = /* @__PURE__ */ new Map();
 var debounceTimers = /* @__PURE__ */ new Map();
@@ -236,18 +265,18 @@ function startPagesWatcher(mindName, pagesDir) {
 }
 function startWatcher(mindName) {
   if (watchers.has(mindName)) return;
-  const pagesDir = resolve(mindDir(mindName), "home", "public", "pages");
-  if (existsSync(pagesDir)) {
+  const pagesDir = resolve2(mindDir(mindName), "home", "public", "pages");
+  if (existsSync2(pagesDir)) {
     startPagesWatcher(mindName, pagesDir);
     return;
   }
   if (homeWatchers.has(mindName)) return;
-  const publicDir = resolve(mindDir(mindName), "home", "public");
-  if (!existsSync(publicDir)) return;
+  const publicDir = resolve2(mindDir(mindName), "home", "public");
+  if (!existsSync2(publicDir)) return;
   try {
     const hw = watch(publicDir, (_eventType, filename) => {
       if (filename !== "pages") return;
-      if (!existsSync(pagesDir)) return;
+      if (!existsSync2(pagesDir)) return;
       hw.close();
       homeWatchers.delete(mindName);
       invalidateCache();
@@ -305,7 +334,7 @@ function scanPagesDir(dir, urlPrefix) {
   }
   for (const item of items) {
     if (item.startsWith(".")) continue;
-    const fullPath = resolve(dir, item);
+    const fullPath = resolve2(dir, item);
     try {
       const s = statSync(fullPath);
       if (s.isFile() && item.endsWith(".html")) {
@@ -315,8 +344,8 @@ function scanPagesDir(dir, urlPrefix) {
           url: `${urlPrefix}/${item}`
         });
       } else if (s.isDirectory()) {
-        const indexPath = resolve(fullPath, "index.html");
-        if (existsSync(indexPath)) {
+        const indexPath = resolve2(fullPath, "index.html");
+        if (existsSync2(indexPath)) {
           const indexStat = statSync(indexPath);
           pages.push({
             file: join(item, "index.html"),
@@ -331,19 +360,19 @@ function scanPagesDir(dir, urlPrefix) {
   pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
   return pages;
 }
-function buildSites() {
+async function buildSites() {
   const sites = [];
-  const systemPagesDir = resolve(voluteHome(), "shared", "pages");
-  if (existsSync(systemPagesDir)) {
+  const systemPagesDir = resolve2(voluteHome(), "shared", "pages");
+  if (existsSync2(systemPagesDir)) {
     const systemPages = scanPagesDir(systemPagesDir, "/pages/_system");
     if (systemPages.length > 0) {
       sites.push({ name: "_system", label: "System", pages: systemPages });
     }
   }
-  const entries = readRegistry();
+  const entries = await readRegistry();
   for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const pagesDir = resolve(mindDir(entry.name), "home", "public", "pages");
-    if (!existsSync(pagesDir)) continue;
+    const pagesDir = resolve2(mindDir(entry.name), "home", "public", "pages");
+    if (!existsSync2(pagesDir)) continue;
     const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
     if (mindPages.length > 0) {
       sites.push({ name: entry.name, label: entry.name, pages: mindPages });
@@ -351,12 +380,12 @@ function buildSites() {
   }
   return sites;
 }
-function buildRecentPages() {
-  const entries = readRegistry();
+async function buildRecentPages() {
+  const entries = await readRegistry();
   const pages = [];
   for (const entry of entries) {
-    const pagesDir = resolve(mindDir(entry.name), "home", "public", "pages");
-    if (!existsSync(pagesDir)) continue;
+    const pagesDir = resolve2(mindDir(entry.name), "home", "public", "pages");
+    if (!existsSync2(pagesDir)) continue;
     let items;
     try {
       items = readdirSync(pagesDir);
@@ -365,7 +394,7 @@ function buildRecentPages() {
     }
     for (const item of items) {
       if (item.startsWith(".")) continue;
-      const fullPath = resolve(pagesDir, item);
+      const fullPath = resolve2(pagesDir, item);
       try {
         const s = statSync(fullPath);
         if (s.isFile() && item.endsWith(".html")) {
@@ -376,8 +405,8 @@ function buildRecentPages() {
             url: `/pages/${entry.name}/${item}`
           });
         } else if (s.isDirectory()) {
-          const indexPath = resolve(fullPath, "index.html");
-          if (existsSync(indexPath)) {
+          const indexPath = resolve2(fullPath, "index.html");
+          if (existsSync2(indexPath)) {
             const indexStat = statSync(indexPath);
             pages.push({
               mind: entry.name,
@@ -394,360 +423,54 @@ function buildRecentPages() {
   pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
   return pages.slice(0, 10);
 }
-function getCachedSites() {
-  if (!sitesCache) sitesCache = buildSites();
+async function getCachedSites() {
+  if (!sitesCache) sitesCache = await buildSites();
   return sitesCache;
 }
-function getCachedRecentPages() {
-  if (!recentPagesCache) recentPagesCache = buildRecentPages();
+async function getCachedRecentPages() {
+  if (!recentPagesCache) recentPagesCache = await buildRecentPages();
   return recentPagesCache;
 }
 
-// src/lib/daemon/connector-manager.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
-import { dirname, resolve as resolve3 } from "path";
-
-// src/lib/connector-defs.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-var BUILTIN_DEFS = {
-  discord: {
-    displayName: "Discord",
-    description: "Connect to Discord as a bot",
-    envVars: [
-      {
-        name: "DISCORD_TOKEN",
-        required: true,
-        description: "Discord bot token",
-        scope: "mind"
-      },
-      {
-        name: "DISCORD_GUILD_ID",
-        required: false,
-        description: "Discord server ID (optional, for slash commands)",
-        scope: "mind"
-      }
-    ]
-  },
-  slack: {
-    displayName: "Slack",
-    description: "Connect to Slack via Socket Mode",
-    envVars: [
-      {
-        name: "SLACK_BOT_TOKEN",
-        required: true,
-        description: "Slack bot token (xoxb-...)",
-        scope: "mind"
-      },
-      {
-        name: "SLACK_APP_TOKEN",
-        required: true,
-        description: "Slack app-level token (xapp-...) for Socket Mode",
-        scope: "mind"
-      }
-    ]
-  },
-  telegram: {
-    displayName: "Telegram",
-    description: "Connect to Telegram via long polling",
-    envVars: [
-      {
-        name: "TELEGRAM_BOT_TOKEN",
-        required: true,
-        description: "Telegram bot token from BotFather",
-        scope: "mind"
-      }
-    ]
-  }
-};
-function getConnectorDef(type, connectorDir) {
-  if (BUILTIN_DEFS[type]) return BUILTIN_DEFS[type];
-  if (connectorDir) {
-    const jsonPath = resolve2(connectorDir, "connector.json");
-    if (existsSync2(jsonPath)) {
-      try {
-        return JSON.parse(readFileSync(jsonPath, "utf-8"));
-      } catch (err) {
-        console.warn(`Failed to parse ${jsonPath}: ${err}`);
-        return null;
-      }
-    }
+// src/connectors/sdk.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve as resolve3 } from "path";
+function splitMessage(text, maxLength) {
+  const chunks = [];
+  while (text.length > maxLength) {
+    let splitAt = text.lastIndexOf("\n", maxLength);
+    if (splitAt < maxLength / 2) splitAt = maxLength;
+    chunks.push(text.slice(0, splitAt));
+    text = text.slice(splitAt).replace(/^\n/, "");
+  }
+  if (text) chunks.push(text);
+  return chunks;
+}
+function readChannelMap(mindName) {
+  const filePath = join2(stateDir(mindName), "channels.json");
+  if (!existsSync3(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf-8"));
+  } catch (err) {
+    console.error(`[sdk] failed to parse ${filePath}:`, err);
+    return {};
   }
-  return null;
 }
-function checkMissingEnvVars(def, env) {
-  return def.envVars.filter((v) => v.required && !env[v.name]);
+function writeChannelEntry(mindName, slug, entry) {
+  const dir = stateDir(mindName);
+  mkdirSync2(dir, { recursive: true });
+  const filePath = join2(dir, "channels.json");
+  const map = readChannelMap(mindName);
+  map[slug] = entry;
+  writeFileSync2(filePath, JSON.stringify(map, null, 2) + "\n");
 }
-
-// src/lib/daemon/connector-manager.ts
-var clog = logger_default.child("connectors");
-function searchUpwards(...segments) {
-  let searchDir = dirname(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = resolve3(searchDir, ...segments);
-    if (existsSync3(candidate)) return candidate;
-    searchDir = dirname(searchDir);
-  }
-  return null;
-}
-var ConnectorManager = class {
-  connectors = /* @__PURE__ */ new Map();
-  stopping = /* @__PURE__ */ new Set();
-  // "mind:type" keys currently being explicitly stopped
-  shuttingDown = false;
-  restartTracker = new RestartTracker();
-  async startConnectors(mindName, mindDir2, mindPort, daemonPort) {
-    const config = readVoluteConfig(mindDir2) ?? {};
-    const types = config.connectors ?? [];
-    await Promise.all(
-      types.map(
-        (type) => this.startConnector(mindName, mindDir2, mindPort, type, daemonPort).catch((err) => {
-          clog.warn(`failed to start connector ${type} for ${mindName}`, logger_default.errorData(err));
-        })
-      )
-    );
-  }
-  checkConnectorEnv(type, mindName, mindDir2) {
-    const mindConnectorDir = resolve3(mindDir2, "connectors", type);
-    const userConnectorDir = resolve3(voluteHome(), "connectors", type);
-    const connectorDir = existsSync3(mindConnectorDir) ? mindConnectorDir : existsSync3(userConnectorDir) ? userConnectorDir : void 0;
-    const def = getConnectorDef(type, connectorDir);
-    if (!def) return null;
-    const env = loadMergedEnv(mindName);
-    const missing = checkMissingEnvVars(def, env);
-    if (missing.length === 0) return null;
-    return {
-      missing: missing.map((v) => ({ name: v.name, description: v.description })),
-      connectorName: def.displayName
-    };
-  }
-  async startConnector(mindName, mindDir2, mindPort, type, daemonPort) {
-    const existing = this.connectors.get(mindName)?.get(type);
-    if (existing) {
-      await new Promise((res) => {
-        existing.child.on("exit", () => res());
-        try {
-          if (existing.child.pid) {
-            process.kill(-existing.child.pid, "SIGTERM");
-          } else {
-            existing.child.kill("SIGTERM");
-          }
-        } catch {
-          res();
-        }
-        setTimeout(() => {
-          try {
-            if (existing.child.pid) {
-              process.kill(-existing.child.pid, "SIGKILL");
-            } else {
-              existing.child.kill("SIGKILL");
-            }
-          } catch {
-          }
-          res();
-        }, 3e3);
-      });
-      this.connectors.get(mindName)?.delete(type);
-    }
-    this.killOrphanConnector(mindName, type);
-    const mindConnector = resolve3(mindDir2, "connectors", type, "index.ts");
-    const userConnector = resolve3(voluteHome(), "connectors", type, "index.ts");
-    const builtinConnector = this.resolveBuiltinConnector(type);
-    let connectorScript;
-    let runtime;
-    if (existsSync3(mindConnector)) {
-      connectorScript = mindConnector;
-      runtime = resolve3(mindDir2, "node_modules", ".bin", "tsx");
-    } else if (existsSync3(userConnector)) {
-      connectorScript = userConnector;
-      runtime = this.resolveVoluteTsx();
-    } else if (builtinConnector) {
-      connectorScript = builtinConnector;
-      runtime = process.execPath;
-    } else {
-      throw new Error(`No connector code found for type: ${type}`);
-    }
-    const mindStateDir = stateDir(mindName);
-    const logsDir = resolve3(mindStateDir, "logs");
-    mkdirSync(logsDir, { recursive: true });
-    if (isIsolationEnabled()) {
-      try {
-        const [base] = mindName.split("@", 2);
-        chownMindDir(mindStateDir, base);
-      } catch (err) {
-        throw new Error(
-          `Cannot start connector ${type} for ${mindName}: failed to set ownership on state directory ${mindStateDir}: ${err instanceof Error ? err.message : err}`
-        );
-      }
-    }
-    const logStream = new RotatingLog(resolve3(logsDir, `${type}.log`));
-    const mindEnv = loadMergedEnv(mindName);
-    const prefix = `${type.toUpperCase()}_`;
-    const connectorEnv = Object.fromEntries(
-      Object.entries(mindEnv).filter(([k]) => k.startsWith(prefix))
-    );
-    const spawnOpts = {
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
-      env: {
-        ...process.env,
-        VOLUTE_MIND_PORT: String(mindPort),
-        VOLUTE_MIND_NAME: mindName,
-        VOLUTE_MIND_DIR: mindDir2,
-        ...daemonPort ? {
-          VOLUTE_DAEMON_URL: `http://${daemonLoopback()}:${daemonPort}`,
-          VOLUTE_DAEMON_TOKEN: process.env.VOLUTE_DAEMON_TOKEN
-        } : {},
-        ...connectorEnv
-      }
-    };
-    const [spawnCmd, spawnArgs] = wrapForIsolation(runtime, [connectorScript], mindName);
-    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
-    let lastStderr = "";
-    child.stdout?.pipe(logStream);
-    child.stderr?.on("data", (chunk) => {
-      logStream.write(chunk);
-      lastStderr = chunk.toString().trim();
-    });
-    if (child.pid) {
-      this.saveConnectorPid(mindName, type, child.pid);
-    }
-    if (!this.connectors.has(mindName)) {
-      this.connectors.set(mindName, /* @__PURE__ */ new Map());
-    }
-    this.connectors.get(mindName).set(type, { child, type });
-    const stopKey = `${mindName}:${type}`;
-    this.restartTracker.reset(stopKey);
-    child.on("exit", (code) => {
-      const mindMap = this.connectors.get(mindName);
-      if (mindMap?.get(type)?.child === child) {
-        mindMap.delete(type);
-      }
-      if (this.shuttingDown) return;
-      if (this.stopping.has(stopKey)) return;
-      clog.error(`connector ${type} for ${mindName} exited with code ${code}`);
-      if (lastStderr) clog.warn(`connector ${type} last output: ${lastStderr}`);
-      const { shouldRestart, delay, attempt } = this.restartTracker.recordCrash(stopKey);
-      if (!shouldRestart) {
-        clog.error(`connector ${type} for ${mindName} crashed ${attempt} times \u2014 giving up`);
-        return;
-      }
-      clog.info(
-        `restarting connector ${type} for ${mindName} \u2014 attempt ${attempt}/${this.restartTracker.maxRestartAttempts}, in ${delay}ms`
-      );
-      setTimeout(() => {
-        if (this.shuttingDown || this.stopping.has(stopKey)) return;
-        this.startConnector(mindName, mindDir2, mindPort, type, daemonPort).catch((err) => {
-          clog.error(`failed to restart connector ${type} for ${mindName}`, logger_default.errorData(err));
-        });
-      }, delay);
-    });
-    clog.info(`started connector ${type} for ${mindName}`);
-  }
-  async stopConnector(mindName, type) {
-    const mindMap = this.connectors.get(mindName);
-    if (!mindMap) return;
-    const tracked = mindMap.get(type);
-    if (!tracked) return;
-    const stopKey = `${mindName}:${type}`;
-    this.stopping.add(stopKey);
-    mindMap.delete(type);
-    await new Promise((resolve9) => {
-      tracked.child.on("exit", () => resolve9());
-      try {
-        process.kill(-tracked.child.pid, "SIGTERM");
-      } catch {
-        resolve9();
-      }
-      setTimeout(() => {
-        try {
-          process.kill(-tracked.child.pid, "SIGKILL");
-        } catch {
-        }
-        resolve9();
-      }, 5e3);
-    });
-    this.stopping.delete(stopKey);
-    this.restartTracker.reset(stopKey);
-    try {
-      this.removeConnectorPid(mindName, type);
-    } catch (err) {
-      clog.warn(`failed to remove PID file for ${type}/${mindName}`, logger_default.errorData(err));
-    }
-    clog.info(`stopped connector ${type} for ${mindName}`);
-  }
-  async stopConnectors(mindName) {
-    const mindMap = this.connectors.get(mindName);
-    if (!mindMap) return;
-    const types = [...mindMap.keys()];
-    await Promise.all(types.map((type) => this.stopConnector(mindName, type)));
-    this.connectors.delete(mindName);
-  }
-  async stopAll() {
-    this.shuttingDown = true;
-    const minds = [...this.connectors.keys()];
-    await Promise.all(minds.map((name) => this.stopConnectors(name)));
-  }
-  getConnectorStatus(mindName) {
-    const mindMap = this.connectors.get(mindName);
-    if (!mindMap) return [];
-    return [...mindMap.entries()].map(([type, tracked]) => ({
-      type,
-      running: !tracked.child.killed
-    }));
-  }
-  connectorPidPath(mindName, type) {
-    return resolve3(stateDir(mindName), "connectors", `${type}.pid`);
-  }
-  saveConnectorPid(mindName, type, pid) {
-    const pidPath = this.connectorPidPath(mindName, type);
-    mkdirSync(dirname(pidPath), { recursive: true });
-    writeFileSync(pidPath, String(pid));
-  }
-  removeConnectorPid(mindName, type) {
-    try {
-      unlinkSync(this.connectorPidPath(mindName, type));
-    } catch {
-    }
+function resolveChannelId(mindName, slug) {
+  const map = readChannelMap(mindName);
+  if (map[slug]) {
+    return map[slug].platformId;
   }
-  killOrphanConnector(mindName, type) {
-    const pidPath = this.connectorPidPath(mindName, type);
-    if (!existsSync3(pidPath)) return;
-    try {
-      const pid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          process.kill(pid, "SIGTERM");
-        }
-        clog.warn(`killed orphan connector ${type} (pid ${pid})`);
-      }
-    } catch {
-    }
-    try {
-      unlinkSync(pidPath);
-    } catch {
-    }
-  }
-  resolveBuiltinConnector(type) {
-    return searchUpwards("connectors", `${type}.js`);
-  }
-  resolveVoluteTsx() {
-    return searchUpwards("node_modules", ".bin", "tsx") ?? "tsx";
-  }
-};
-var instance = null;
-function initConnectorManager() {
-  if (instance) throw new Error("ConnectorManager already initialized");
-  instance = new ConnectorManager();
-  return instance;
-}
-function getConnectorManager() {
-  if (!instance)
-    throw new Error("ConnectorManager not initialized \u2014 call initConnectorManager() first");
-  return instance;
+  const colonIndex = slug.indexOf(":");
+  return colonIndex >= 0 ? slug.slice(colonIndex + 1) : slug;
 }
 
 // src/lib/events/mind-events.ts
@@ -764,7 +487,7 @@ function subscribe2(mind, callback) {
     if (set.size === 0) subscribers.delete(mind);
   };
 }
-function publish2(mind, event) {
+function publish3(mind, event) {
   const set = subscribers.get(mind);
   if (!set) return;
   for (const cb of set) {
@@ -781,425 +504,7 @@ function publish2(mind, event) {
 // src/lib/delivery/delivery-manager.ts
 import { readFile, realpath } from "fs/promises";
 import { extname, resolve as resolve5 } from "path";
-import { and as and3, eq as eq3, sql as sql2 } from "drizzle-orm";
-
-// src/lib/events/conversations.ts
-import { randomUUID } from "crypto";
-import { and as and2, desc, eq as eq2, inArray, isNull, lt, sql } from "drizzle-orm";
-
-// src/lib/webhook.ts
-var slog = logger_default.child("webhook");
-function getWebhookUrl() {
-  return process.env.VOLUTE_WEBHOOK_URL;
-}
-function getAuthHeaders() {
-  const headers = { "Content-Type": "application/json" };
-  const secret = process.env.VOLUTE_WEBHOOK_SECRET;
-  if (secret) headers.Authorization = `Bearer ${secret}`;
-  return headers;
-}
-function fireWebhook(event) {
-  try {
-    const url = getWebhookUrl();
-    if (!url) return;
-    const payload = { ...event, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() };
-    fetch(url, {
-      method: "POST",
-      headers: getAuthHeaders(),
-      body: JSON.stringify(payload)
-    }).then((res) => {
-      if (!res.ok) {
-        slog.warn(`webhook ${event.event} returned HTTP ${res.status}`);
-      }
-    }).catch((err) => {
-      slog.warn(`webhook delivery failed for ${event.event}`, logger_default.errorData(err));
-    });
-  } catch (err) {
-    slog.error(`webhook ${event.event} failed to serialize`, logger_default.errorData(err));
-  }
-}
-function initWebhook() {
-  const url = getWebhookUrl();
-  if (!url) return () => {
-  };
-  try {
-    const parsed = new URL(url);
-    if (!["http:", "https:"].includes(parsed.protocol)) {
-      slog.error(`VOLUTE_WEBHOOK_URL has unsupported protocol: ${parsed.protocol}`);
-      return () => {
-      };
-    }
-  } catch {
-    slog.error(`VOLUTE_WEBHOOK_URL is not a valid URL`);
-    return () => {
-    };
-  }
-  slog.info("webhook enabled");
-  return subscribe((event) => {
-    try {
-      fireWebhook({
-        event: event.type,
-        mind: event.mind,
-        data: { summary: event.summary, ...event.metadata },
-        timestamp: event.created_at
-      });
-    } catch (err) {
-      slog.error(`failed to fire webhook for ${event.type}`, logger_default.errorData(err));
-    }
-  });
-}
-
-// src/lib/events/conversation-events.ts
-var subscribers2 = /* @__PURE__ */ new Map();
-function subscribe3(conversationId, callback) {
-  let set = subscribers2.get(conversationId);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    subscribers2.set(conversationId, set);
-  }
-  set.add(callback);
-  return () => {
-    set.delete(callback);
-    if (set.size === 0) subscribers2.delete(conversationId);
-  };
-}
-function publish3(conversationId, event) {
-  const set = subscribers2.get(conversationId);
-  if (!set) return;
-  for (const cb of set) {
-    try {
-      cb(event);
-    } catch (err) {
-      console.error("[conversation-events] subscriber threw:", err);
-      set.delete(cb);
-      if (set.size === 0) subscribers2.delete(conversationId);
-    }
-  }
-}
-
-// src/lib/events/conversations.ts
-async function createConversation(mindName, channel, opts) {
-  const db = await getDb();
-  const id = randomUUID();
-  const type = opts?.type ?? "dm";
-  const name = opts?.name ?? null;
-  await db.transaction(async (tx) => {
-    await tx.insert(conversations).values({
-      id,
-      mind_name: mindName,
-      channel,
-      type,
-      name,
-      user_id: opts?.userId ?? null,
-      title: opts?.title ?? null
-    });
-    if (opts?.participantIds && opts.participantIds.length > 0) {
-      await tx.insert(conversationParticipants).values(
-        opts.participantIds.map((uid, i) => ({
-          conversation_id: id,
-          user_id: uid,
-          role: i === 0 ? "owner" : "member"
-        }))
-      );
-    }
-  });
-  fireWebhook({
-    event: "conversation_created",
-    mind: mindName ?? "",
-    data: { id, mindName, channel, type, name, title: opts?.title ?? null }
-  });
-  return {
-    id,
-    mind_name: mindName,
-    channel,
-    type,
-    name,
-    user_id: opts?.userId ?? null,
-    title: opts?.title ?? null,
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-async function getConversation(id) {
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(eq2(conversations.id, id)).get();
-  return row ?? null;
-}
-async function addParticipant(conversationId, userId, role = "member") {
-  const db = await getDb();
-  await db.insert(conversationParticipants).values({
-    conversation_id: conversationId,
-    user_id: userId,
-    role
-  });
-}
-async function removeParticipant(conversationId, userId) {
-  const db = await getDb();
-  await db.delete(conversationParticipants).where(
-    and2(
-      eq2(conversationParticipants.conversation_id, conversationId),
-      eq2(conversationParticipants.user_id, userId)
-    )
-  );
-}
-async function getParticipants(conversationId) {
-  const db = await getDb();
-  const rows = await db.select({
-    userId: conversationParticipants.user_id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role,
-    displayName: users.display_name,
-    description: users.description,
-    avatar: users.avatar
-  }).from(conversationParticipants).innerJoin(users, eq2(conversationParticipants.user_id, users.id)).where(eq2(conversationParticipants.conversation_id, conversationId)).all();
-  return rows;
-}
-async function isParticipant(conversationId, userId) {
-  const db = await getDb();
-  const row = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(
-    and2(
-      eq2(conversationParticipants.conversation_id, conversationId),
-      eq2(conversationParticipants.user_id, userId)
-    )
-  ).get();
-  return row != null;
-}
-async function listConversationsForUser(userId) {
-  const db = await getDb();
-  const participantRows = await db.select({ conversation_id: conversationParticipants.conversation_id }).from(conversationParticipants).where(eq2(conversationParticipants.user_id, userId)).all();
-  if (participantRows.length === 0) return [];
-  const convIds = participantRows.map((r) => r.conversation_id);
-  return await db.select().from(conversations).where(inArray(conversations.id, convIds)).orderBy(desc(conversations.updated_at)).all();
-}
-async function isParticipantOrOwner(conversationId, userId) {
-  if (await isParticipant(conversationId, userId)) return true;
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq2(conversations.id, conversationId), eq2(conversations.user_id, userId))).get();
-  return row != null;
-}
-async function deleteConversationForUser(id, userId) {
-  if (!await isParticipantOrOwner(id, userId)) return false;
-  await deleteConversation(id);
-  return true;
-}
-async function addMessage(conversationId, role, senderName, content) {
-  const db = await getDb();
-  const serialized = JSON.stringify(content);
-  const [result] = await db.insert(messages).values({ conversation_id: conversationId, role, sender_name: senderName, content: serialized }).returning({ id: messages.id, created_at: messages.created_at });
-  await db.update(conversations).set({ updated_at: sql`datetime('now')` }).where(eq2(conversations.id, conversationId));
-  if (role === "user") {
-    const firstText = content.find((b) => b.type === "text");
-    const title = firstText ? firstText.text.slice(0, 80) : "";
-    if (title) {
-      await db.update(conversations).set({ title }).where(and2(eq2(conversations.id, conversationId), isNull(conversations.title)));
-    }
-  }
-  const msg = {
-    id: result.id,
-    conversation_id: conversationId,
-    role,
-    sender_name: senderName,
-    content,
-    created_at: result.created_at
-  };
-  publish3(conversationId, {
-    type: "message",
-    id: msg.id,
-    role: msg.role,
-    senderName: msg.sender_name,
-    content: msg.content,
-    createdAt: msg.created_at
-  });
-  const conv = await db.select({ mind_name: conversations.mind_name }).from(conversations).where(eq2(conversations.id, conversationId)).get();
-  fireWebhook({
-    event: "message_created",
-    mind: conv?.mind_name ?? "",
-    data: {
-      conversationId,
-      messageId: result.id,
-      role,
-      senderName,
-      content: content.filter((b) => b.type !== "image"),
-      createdAt: result.created_at
-    }
-  });
-  return msg;
-}
-async function getMessages(conversationId) {
-  const db = await getDb();
-  const rows = await db.select().from(messages).where(eq2(messages.conversation_id, conversationId)).orderBy(messages.created_at).all();
-  return rows.map(parseMessageRow);
-}
-async function getMessagesPaginated(conversationId, opts) {
-  const db = await getDb();
-  const limit = Math.min(Math.max(opts?.limit ?? 50, 1), 100);
-  const conditions = [eq2(messages.conversation_id, conversationId)];
-  if (opts?.before != null) {
-    conditions.push(lt(messages.id, opts.before));
-  }
-  const rows = await db.select().from(messages).where(and2(...conditions)).orderBy(desc(messages.id)).limit(limit + 1).all();
-  const hasMore = rows.length > limit;
-  const page = rows.slice(0, limit).reverse();
-  return {
-    messages: page.map(parseMessageRow),
-    hasMore
-  };
-}
-function parseMessageRow(row) {
-  let content;
-  try {
-    const parsed = JSON.parse(row.content);
-    content = Array.isArray(parsed) ? parsed : [{ type: "text", text: row.content }];
-  } catch {
-    content = [{ type: "text", text: row.content }];
-  }
-  return { ...row, role: row.role, content };
-}
-async function listConversationsWithParticipants(userId) {
-  const convs = await listConversationsForUser(userId);
-  if (convs.length === 0) return [];
-  const db = await getDb();
-  const convIds = convs.map((c) => c.id);
-  const rows = await db.select({
-    conversationId: conversationParticipants.conversation_id,
-    userId: users.id,
-    username: users.username,
-    userType: users.user_type,
-    role: conversationParticipants.role,
-    displayName: users.display_name,
-    description: users.description,
-    avatar: users.avatar
-  }).from(conversationParticipants).innerJoin(users, eq2(conversationParticipants.user_id, users.id)).where(inArray(conversationParticipants.conversation_id, convIds));
-  const byConv = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    let arr = byConv.get(r.conversationId);
-    if (!arr) {
-      arr = [];
-      byConv.set(r.conversationId, arr);
-    }
-    arr.push({
-      userId: r.userId,
-      username: r.username,
-      userType: r.userType,
-      role: r.role,
-      displayName: r.displayName,
-      description: r.description,
-      avatar: r.avatar
-    });
-  }
-  const lastMsgIds = await db.select({
-    conversationId: messages.conversation_id,
-    maxId: sql`MAX(${messages.id})`
-  }).from(messages).where(inArray(messages.conversation_id, convIds)).groupBy(messages.conversation_id);
-  const byLastMsg = /* @__PURE__ */ new Map();
-  if (lastMsgIds.length > 0) {
-    const msgRows = await db.select().from(messages).where(
-      inArray(
-        messages.id,
-        lastMsgIds.map((r) => r.maxId)
-      )
-    );
-    for (const m of msgRows) {
-      let text = "";
-      try {
-        const parsed = JSON.parse(m.content);
-        const blocks = Array.isArray(parsed) ? parsed : [];
-        const textBlock = blocks.find((b) => b.type === "text");
-        if (textBlock && "text" in textBlock) text = textBlock.text;
-      } catch {
-        text = m.content;
-      }
-      byLastMsg.set(m.conversation_id, {
-        role: m.role,
-        senderName: m.sender_name,
-        text,
-        createdAt: m.created_at
-      });
-    }
-  }
-  return convs.map((c) => ({
-    ...c,
-    participants: byConv.get(c.id) ?? [],
-    lastMessage: byLastMsg.get(c.id)
-  }));
-}
-async function findDMConversation(mindName, participantIds) {
-  const db = await getDb();
-  const mindConvs = await db.select({ id: conversations.id }).from(conversations).where(and2(eq2(conversations.mind_name, mindName), eq2(conversations.type, "dm"))).all();
-  for (const conv of mindConvs) {
-    const rows = await db.select({ user_id: conversationParticipants.user_id }).from(conversationParticipants).where(eq2(conversationParticipants.conversation_id, conv.id)).all();
-    if (rows.length !== 2) continue;
-    const ids = new Set(rows.map((r) => r.user_id));
-    if (ids.has(participantIds[0]) && ids.has(participantIds[1])) {
-      return conv.id;
-    }
-  }
-  return null;
-}
-async function deleteConversation(id) {
-  const db = await getDb();
-  await db.delete(conversations).where(eq2(conversations.id, id));
-}
-async function createChannel(name, creatorId) {
-  const participantIds = creatorId ? [creatorId] : [];
-  return createConversation(null, "volute", {
-    type: "channel",
-    name,
-    title: name,
-    participantIds
-  });
-}
-async function getChannelByName(name) {
-  const db = await getDb();
-  const row = await db.select().from(conversations).where(and2(eq2(conversations.name, name), eq2(conversations.type, "channel"))).get();
-  return row ?? null;
-}
-async function listChannels() {
-  const db = await getDb();
-  return await db.select().from(conversations).where(eq2(conversations.type, "channel")).orderBy(conversations.name).all();
-}
-async function joinChannel(conversationId, userId) {
-  if (await isParticipant(conversationId, userId)) return;
-  await addParticipant(conversationId, userId);
-}
-async function leaveChannel(conversationId, userId) {
-  await removeParticipant(conversationId, userId);
-}
-async function getUnreadCounts(userId, conversationIds) {
-  if (conversationIds.length === 0) return {};
-  const db = await getDb();
-  const rows = await db.select({
-    conversationId: messages.conversation_id,
-    count: sql`COUNT(*)`
-  }).from(messages).leftJoin(
-    conversationReads,
-    and2(
-      eq2(conversationReads.conversation_id, messages.conversation_id),
-      eq2(conversationReads.user_id, userId)
-    )
-  ).where(
-    and2(
-      inArray(messages.conversation_id, conversationIds),
-      sql`${messages.id} > COALESCE(${conversationReads.last_read_message_id}, 0)`
-    )
-  ).groupBy(messages.conversation_id);
-  const result = {};
-  for (const row of rows) {
-    result[row.conversationId] = row.count;
-  }
-  return result;
-}
-async function markConversationRead(userId, conversationId) {
-  const db = await getDb();
-  const maxRow = await db.select({ maxId: sql`MAX(${messages.id})` }).from(messages).where(eq2(messages.conversation_id, conversationId)).get();
-  const maxId = maxRow?.maxId ?? 0;
-  if (maxId === 0) return;
-  await db.insert(conversationReads).values({ user_id: userId, conversation_id: conversationId, last_read_message_id: maxId }).onConflictDoUpdate({
-    target: [conversationReads.user_id, conversationReads.conversation_id],
-    set: { last_read_message_id: maxId }
-  });
-}
+import { and as and2, eq as eq2, sql } from "drizzle-orm";
 
 // src/lib/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -1259,7 +564,7 @@ var TypingMap = class {
   dispose() {
     clearInterval(this.sweepTimer);
     this.channels.clear();
-    if (instance2 === this) instance2 = void 0;
+    if (instance === this) instance = void 0;
   }
   sweep() {
     const now = Date.now();
@@ -1275,18 +580,18 @@ var TypingMap = class {
     }
   }
 };
-var instance2;
+var instance;
 function getTypingMap() {
-  if (!instance2) {
-    instance2 = new TypingMap();
+  if (!instance) {
+    instance = new TypingMap();
   }
-  return instance2;
+  return instance;
 }
 function publishTypingForChannels(channels, map) {
   for (const channel of channels) {
     if (channel.startsWith(VOLUTE_PREFIX)) {
       const conversationId = channel.slice(VOLUTE_PREFIX.length);
-      publish3(conversationId, { type: "typing", senders: map.get(channel) });
+      publish2(conversationId, { type: "typing", senders: map.get(channel) });
     }
   }
 }
@@ -1500,7 +805,7 @@ var DeliveryManager = class {
    * or queued for batching depending on the session's delivery mode.
    */
   async routeAndDeliver(mindName, payload) {
-    const [baseName] = mindName.split("@", 2);
+    const baseName = await getBaseName(mindName);
     const config = getRoutingConfig(baseName);
     const meta = {
       channel: payload.channel,
@@ -1536,7 +841,7 @@ var DeliveryManager = class {
     const sessionConfig = resolveDeliveryMode(config, sessionName, route.rule);
     if (sessionConfig.delivery.mode === "batch") {
       dlog2.debug(`enqueueing batch message for ${mindName}/${sessionName}`);
-      this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
+      await this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
       return { routed: true, session: sessionName, destination: "mind", mode: "batch" };
     }
     await this.deliverToMind(mindName, sessionName, payload, sessionConfig);
@@ -1546,8 +851,8 @@ var DeliveryManager = class {
    * Called when a mind's session emits a "done" event — decrements active count
    * and may trigger batch flush if session goes idle.
    */
-  sessionDone(mindName, session) {
-    const [baseName] = mindName.split("@", 2);
+  async sessionDone(mindName, session) {
+    const baseName = await getBaseName(mindName);
     if (session) {
       this.decrementActive(baseName, session);
     } else {
@@ -1565,7 +870,7 @@ var DeliveryManager = class {
   async restoreFromDb() {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(eq3(deliveryQueue.status, "pending"));
+      const rows = await db.select().from(deliveryQueue).where(eq2(deliveryQueue.status, "pending"));
       for (const row of rows) {
         let payload;
         try {
@@ -1583,7 +888,7 @@ var DeliveryManager = class {
           this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
         } else {
           try {
-            await db.delete(deliveryQueue).where(eq3(deliveryQueue.id, row.id));
+            await db.delete(deliveryQueue).where(eq2(deliveryQueue.id, row.id));
           } catch (err) {
             dlog2.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
           }
@@ -1604,7 +909,7 @@ var DeliveryManager = class {
    */
   async getPending(mindName) {
     const db = await getDb();
-    const rows = await db.select().from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, mindName), eq3(deliveryQueue.status, "gated")));
+    const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, mindName), eq2(deliveryQueue.status, "gated")));
     const byChannel = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const ch = row.channel ?? "unknown";
@@ -1642,18 +947,13 @@ var DeliveryManager = class {
     }
     this.batchBuffers.clear();
     this.sessionStates.clear();
-    if (instance3 === this) instance3 = void 0;
+    if (instance2 === this) instance2 = void 0;
   }
   // --- Private ---
-  resolvePort(mindName) {
-    const [baseName, variantName] = mindName.split("@", 2);
-    const entry = findMind(baseName);
+  async resolvePort(mindName) {
+    const entry = await findMind(mindName);
     if (!entry) return null;
-    if (variantName) {
-      const variant = findVariant(baseName, variantName);
-      if (!variant) return null;
-      return { baseName, port: variant.port };
-    }
+    const baseName = entry.parent ?? mindName;
     return { baseName, port: entry.port };
   }
   async postToMind(port, body) {
@@ -1679,7 +979,7 @@ var DeliveryManager = class {
     }
   }
   async deliverToMind(mindName, session, payload, sessionConfig) {
-    const resolved = this.resolvePort(mindName);
+    const resolved = await this.resolvePort(mindName);
     if (!resolved) {
       dlog2.warn(`cannot deliver to ${mindName}: mind not found`);
       return;
@@ -1716,16 +1016,16 @@ var DeliveryManager = class {
       publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
     }
   }
-  async deliverBatchToMind(mindName, session, messages2, sessionConfig, interruptOverride) {
-    const resolved = this.resolvePort(mindName);
+  async deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride) {
+    const resolved = await this.resolvePort(mindName);
     if (!resolved) {
       dlog2.warn(`cannot deliver batch to ${mindName}: mind not found`);
       return;
     }
     const { baseName, port } = resolved;
     const enrichedMessages = await Promise.all(
-      messages2.map(async (msg, i) => {
-        const isFirst = messages2.findIndex((m) => m.channel === msg.channel) === i;
+      messages.map(async (msg, i) => {
+        const isFirst = messages.findIndex((m) => m.channel === msg.channel) === i;
         if (!isFirst) return msg;
         const enrichedPayload = await this.enrichWithProfiles(baseName, session, msg.payload);
         return { ...msg, payload: enrichedPayload };
@@ -1739,7 +1039,7 @@ var DeliveryManager = class {
     }
     const senders = /* @__PURE__ */ new Set();
     const channelSet = /* @__PURE__ */ new Set();
-    for (const msg of messages2) {
+    for (const msg of messages) {
       if (msg.sender) senders.add(msg.sender);
       if (msg.channel) channelSet.add(msg.channel);
     }
@@ -1749,7 +1049,7 @@ var DeliveryManager = class {
       if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
     }
     const seenConvIds = /* @__PURE__ */ new Set();
-    for (const msg of messages2) {
+    for (const msg of messages) {
       if (msg.payload.conversationId && !seenConvIds.has(msg.payload.conversationId)) {
         seenConvIds.add(msg.payload.conversationId);
         typingMap.set(`volute:${msg.payload.conversationId}`, baseName, { persistent: true });
@@ -1770,10 +1070,10 @@ var DeliveryManager = class {
         try {
           const db = await getDb();
           await db.delete(deliveryQueue).where(
-            and3(
-              eq3(deliveryQueue.mind, baseName),
-              eq3(deliveryQueue.session, session),
-              eq3(deliveryQueue.status, "pending")
+            and2(
+              eq2(deliveryQueue.mind, baseName),
+              eq2(deliveryQueue.session, session),
+              eq2(deliveryQueue.status, "pending")
             )
           );
         } catch (err) {
@@ -1789,13 +1089,13 @@ var DeliveryManager = class {
       publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
     }
   }
-  enqueueBatch(mindName, session, payload, sessionConfig) {
+  async enqueueBatch(mindName, session, payload, sessionConfig) {
     const delivery = sessionConfig.delivery;
     if (delivery.triggers?.length) {
       const text = extractTextContent(payload.content);
       const lower = text.toLowerCase();
       if (delivery.triggers.some((t) => lower.includes(t.toLowerCase()))) {
-        this.flushBatch(mindName, session, [
+        await this.flushBatch(mindName, session, [
           {
             payload,
             channel: payload.channel,
@@ -1806,14 +1106,14 @@ var DeliveryManager = class {
         return;
       }
     }
-    const [baseName] = mindName.split("@", 2);
+    const baseName = await getBaseName(mindName);
     const state = this.sessionStates.get(baseName)?.get(session);
     if (state && state.activeCount > 0 && payload.sender && !state.lastDeliverySenders.has(payload.sender) && payload.channel && state.lastDeliveryChannels.has(payload.channel) && Date.now() - state.lastDeliveredAt < delivery.maxWait * 1e3 && Date.now() - state.lastInterruptAt > delivery.debounce * 1e3) {
       state.lastInterruptAt = Date.now();
       this.persistToQueue(mindName, session, payload).catch((err) => {
         dlog2.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
       });
-      this.flushBatch(
+      await this.flushBatch(
         mindName,
         session,
         [{ payload, channel: payload.channel, sender: payload.sender, createdAt: Date.now() }],
@@ -1868,42 +1168,42 @@ var DeliveryManager = class {
       buffer.maxWaitTimer.unref();
     }
   }
-  flushBatch(mindName, session, extra, interruptOverride) {
+  async flushBatch(mindName, session, extra, interruptOverride) {
     const bufferKey = `${mindName}:${session}`;
     const buffer = this.batchBuffers.get(bufferKey);
-    const messages2 = [];
+    const messages = [];
     if (buffer) {
       if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
       if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
       buffer.debounceTimer = null;
       buffer.maxWaitTimer = null;
-      messages2.push(...buffer.messages.splice(0));
+      messages.push(...buffer.messages.splice(0));
       this.batchBuffers.delete(bufferKey);
     }
-    if (extra) messages2.push(...extra);
-    if (messages2.length === 0) return;
-    const [baseName] = mindName.split("@", 2);
+    if (extra) messages.push(...extra);
+    if (messages.length === 0) return;
+    const baseName = await getBaseName(mindName);
     const config = getRoutingConfig(baseName);
     const sessionConfig = resolveDeliveryMode(config, session);
     dlog2.info(
-      `flushing batch for ${mindName}/${session}: ${messages2.length} messages${interruptOverride ? " (new-speaker interrupt)" : ""}`
+      `flushing batch for ${mindName}/${session}: ${messages.length} messages${interruptOverride ? " (new-speaker interrupt)" : ""}`
     );
-    this.deliverBatchToMind(mindName, session, messages2, sessionConfig, interruptOverride).catch(
+    this.deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride).catch(
       (err) => {
         dlog2.warn(`failed to flush batch for ${mindName}/${session}`, logger_default.errorData(err));
       }
     );
   }
   async gateMessage(mindName, session, payload) {
-    const [baseName] = mindName.split("@", 2);
+    const baseName = await getBaseName(mindName);
     await this.persistToQueue(baseName, session, payload, "gated");
     try {
       const db = await getDb();
-      const count2 = await db.select({ count: sql2`count(*)` }).from(deliveryQueue).where(
-        and3(
-          eq3(deliveryQueue.mind, baseName),
-          eq3(deliveryQueue.channel, payload.channel),
-          eq3(deliveryQueue.status, "gated")
+      const count2 = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
+        and2(
+          eq2(deliveryQueue.mind, baseName),
+          eq2(deliveryQueue.channel, payload.channel),
+          eq2(deliveryQueue.status, "gated")
         )
       );
       if ((count2[0]?.count ?? 0) <= 1) {
@@ -1933,7 +1233,7 @@ var DeliveryManager = class {
       sender: "system",
       content: [{ type: "text", text: notification }]
     };
-    const config = getRoutingConfig(mindName.split("@", 2)[0]);
+    const config = getRoutingConfig(await getBaseName(mindName));
     const sessionConfig = resolveDeliveryMode(config, "main");
     await this.deliverToMind(mindName, "main", invitePayload, {
       ...sessionConfig,
@@ -2077,17 +1377,17 @@ var DeliveryManager = class {
     }
   }
 };
-var instance3;
+var instance2;
 function initDeliveryManager() {
-  if (instance3) throw new Error("DeliveryManager already initialized");
-  instance3 = new DeliveryManager();
-  return instance3;
+  if (instance2) throw new Error("DeliveryManager already initialized");
+  instance2 = new DeliveryManager();
+  return instance2;
 }
 function getDeliveryManager() {
-  if (!instance3) {
+  if (!instance2) {
     throw new Error("DeliveryManager not initialized \u2014 call initDeliveryManager() first");
   }
-  return instance3;
+  return instance2;
 }
 
 // src/lib/delivery/message-delivery.ts
@@ -2105,7 +1405,7 @@ async function recordInbound(mind, channel, sender, content) {
   } catch (err) {
     dlog3.warn(`failed to persist inbound for ${mind}`, logger_default.errorData(err));
   }
-  publish2(mind, {
+  publish3(mind, {
     mind,
     type: "inbound",
     channel,
@@ -2114,8 +1414,8 @@ async function recordInbound(mind, channel, sender, content) {
 }
 async function deliverMessage(mindName, payload) {
   try {
-    const [baseName] = mindName.split("@", 2);
-    const entry = findMind(baseName);
+    const baseName = await getBaseName(mindName);
+    const entry = await findMind(baseName);
     if (!entry) {
       dlog3.warn(`cannot deliver to ${mindName}: mind not found`);
       return;
@@ -2139,6 +1439,60 @@ async function deliverMessage(mindName, payload) {
   }
 }
 
+// src/lib/system-channel.ts
+var SYSTEM_CHANNEL_NAME = "system";
+var cachedChannelId = null;
+async function ensureSystemChannel() {
+  if (cachedChannelId) return cachedChannelId;
+  const existing = await getChannelByName(SYSTEM_CHANNEL_NAME);
+  if (existing) {
+    cachedChannelId = existing.id;
+    return existing.id;
+  }
+  const conv = await createChannel(SYSTEM_CHANNEL_NAME);
+  cachedChannelId = conv.id;
+  logger_default.info("created #system channel");
+  return conv.id;
+}
+async function joinSystemChannel(userId) {
+  const channelId = await ensureSystemChannel();
+  await joinChannel(channelId, userId);
+}
+async function joinSystemChannelForMind(mindName) {
+  const user = await getOrCreateMindUser(mindName);
+  await joinSystemChannel(user.id);
+}
+async function announceToSystem(text) {
+  const channelId = await ensureSystemChannel();
+  await addMessage(channelId, "system", "system", [{ type: "text", text }]);
+  const participants = await getParticipants(channelId);
+  const mindParticipants = participants.filter((p) => p.userType === "mind");
+  const channel = "volute:#system";
+  for (const mind of mindParticipants) {
+    try {
+      writeChannelEntry(mind.username, channel, {
+        platformId: channelId,
+        platform: "volute",
+        name: SYSTEM_CHANNEL_NAME,
+        type: "group"
+      });
+    } catch (err) {
+      logger_default.warn(`failed to write channel entry for ${mind.username}`, logger_default.errorData(err));
+    }
+    deliverMessage(mind.username, {
+      content: [{ type: "text", text }],
+      channel,
+      conversationId: channelId,
+      sender: "system",
+      participants: participants.map((p) => p.username),
+      participantCount: participants.length,
+      isDM: false
+    }).catch((err) => {
+      logger_default.warn(`failed to deliver system announcement to ${mind.username}`, logger_default.errorData(err));
+    });
+  }
+}
+
 // src/lib/daemon/mail-poller.ts
 var mlog = logger_default.child("mail");
 function formatEmailContent(email) {
@@ -2325,7 +1679,7 @@ var MailPoller = class {
     await this.deliver(mind, { ...email, mind });
   }
   async deliver(mind, email) {
-    const entry = findMind(mind);
+    const entry = await findMind(mind);
     if (!entry || !entry.running) {
       mlog.warn(`skipping delivery to ${mind}: ${!entry ? "not found" : "not running"}`);
       return;
@@ -2345,15 +1699,11 @@ var MailPoller = class {
     }
   }
 };
-var instance4 = null;
+var instance3 = null;
 function initMailPoller() {
-  if (instance4) throw new Error("MailPoller already initialized");
-  instance4 = new MailPoller();
-  return instance4;
-}
-function getMailPoller() {
-  if (!instance4) throw new Error("MailPoller not initialized \u2014 call initMailPoller() first");
-  return instance4;
+  if (instance3) throw new Error("MailPoller already initialized");
+  instance3 = new MailPoller();
+  return instance3;
 }
 async function ensureMailAddress(mindName) {
   const config = readSystemsConfig();
@@ -2379,14 +1729,14 @@ async function ensureMailAddress(mindName) {
 // src/lib/daemon/scheduler.ts
 import { resolve as resolve6 } from "path";
 import { CronExpressionParser } from "cron-parser";
-var slog2 = logger_default.child("scheduler");
+var slog = logger_default.child("scheduler");
 var Scheduler = class {
   schedules = /* @__PURE__ */ new Map();
   interval = null;
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
   get statePath() {
-    return resolve6(voluteHome(), "scheduler-state.json");
+    return resolve6(voluteSystemDir(), "scheduler-state.json");
   }
   start() {
     this.loadState();
@@ -2445,7 +1795,7 @@ var Scheduler = class {
         prevMinute = Math.floor(prev.getTime() / 6e4);
         cronCache.set(schedule.cron, prevMinute);
       } catch (err) {
-        slog2.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
         return false;
       }
     }
@@ -2456,6 +1806,18 @@ var Scheduler = class {
     return false;
   }
   async fire(mindName, schedule) {
+    const sleepManager = getSleepManagerIfReady();
+    const sleepState = sleepManager?.getState(mindName);
+    if (sleepState?.sleeping) {
+      if (schedule.skipWhenSleeping) {
+        slog.info(`skipped "${schedule.id}" for ${mindName} (sleeping)`);
+        return;
+      }
+      if (sleepState.wokenByTrigger) {
+        slog.info(`skipped "${schedule.id}" for ${mindName} (trigger-woken)`);
+        return;
+      }
+    }
     try {
       let text;
       if (schedule.script) {
@@ -2463,7 +1825,7 @@ var Scheduler = class {
         try {
           const output = await this.runScript(schedule.script, homeDir, mindName);
           if (!output.trim()) {
-            slog2.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
             return;
           }
           text = output;
@@ -2471,22 +1833,22 @@ var Scheduler = class {
           const stderr = err.stderr ?? "";
           text = `[script error] ${err.message}${stderr ? `
 ${stderr}` : ""}`;
-          slog2.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
         }
       } else if (schedule.message) {
         text = schedule.message;
       } else {
-        slog2.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
+        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
         return;
       }
       await this.deliver(mindName, {
         content: [{ type: "text", text }],
-        channel: "system:scheduler",
+        channel: schedule.channel ?? "system:scheduler",
         sender: schedule.id
       });
-      slog2.info(`fired "${schedule.id}" for ${mindName}`);
+      slog.info(`fired "${schedule.id}" for ${mindName}`);
     } catch (err) {
-      slog2.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
+      slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
     }
   }
   runScript(script, cwd, mindName) {
@@ -2496,19 +1858,19 @@ ${stderr}` : ""}`;
     return deliverMessage(mindName, payload);
   }
 };
-var instance5 = null;
+var instance4 = null;
 function initScheduler() {
-  if (instance5) throw new Error("Scheduler already initialized");
-  instance5 = new Scheduler();
-  return instance5;
+  if (instance4) throw new Error("Scheduler already initialized");
+  instance4 = new Scheduler();
+  return instance4;
 }
 function getScheduler() {
-  if (!instance5) throw new Error("Scheduler not initialized \u2014 call initScheduler() first");
-  return instance5;
+  if (!instance4) throw new Error("Scheduler not initialized \u2014 call initScheduler() first");
+  return instance4;
 }
 
 // src/lib/daemon/token-budget.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { resolve as resolve7 } from "path";
 var tlog = logger_default.child("token-budget");
 var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
@@ -2583,9 +1945,9 @@ var TokenBudget = class {
   drain(mind) {
     const state = this.budgets.get(mind);
     if (!state) return [];
-    const messages2 = state.queue;
+    const messages = state.queue;
     state.queue = [];
-    return messages2;
+    return messages;
   }
   getUsage(mind) {
     const state = this.budgets.get(mind);
@@ -2632,14 +1994,14 @@ var TokenBudget = class {
   saveBudgetState(mind, state) {
     try {
       const dir = stateDir(mind);
-      mkdirSync2(dir, { recursive: true });
+      mkdirSync3(dir, { recursive: true });
       const data = {
         periodStart: state.periodStart,
         tokensUsed: state.tokensUsed,
         warningInjected: state.warningInjected,
         queue: state.queue
       };
-      writeFileSync2(this.budgetStatePath(mind), `${JSON.stringify(data)}
+      writeFileSync3(this.budgetStatePath(mind), `${JSON.stringify(data)}
 `);
     } catch (err) {
       tlog.warn(`failed to save budget state for ${mind}`, logger_default.errorData(err));
@@ -2666,8 +2028,8 @@ var TokenBudget = class {
       return null;
     }
   }
-  async replay(mindName, messages2) {
-    const summary = messages2.map((m) => {
+  async replay(mindName, messages) {
+    const summary = messages.map((m) => {
       const from = m.sender ? `[${m.sender}]` : "";
       const ch = m.channel ? `(${m.channel})` : "";
       return `${from}${ch} ${m.textContent}`;
@@ -2677,7 +2039,7 @@ var TokenBudget = class {
         content: [
           {
             type: "text",
-            text: `[Budget replay] ${messages2.length} queued message(s) from the previous budget period:
+            text: `[Budget replay] ${messages.length} queued message(s) from the previous budget period:
 
 ${summary}`
           }
@@ -2685,40 +2047,38 @@ ${summary}`
         channel: "system:budget-replay",
         sender: "system"
       });
-      tlog.info(`replayed ${messages2.length} queued message(s) for ${mindName}`);
+      tlog.info(`replayed ${messages.length} queued message(s) for ${mindName}`);
     } catch (err) {
       tlog.warn(`failed to replay for ${mindName}`, logger_default.errorData(err));
       const state = this.budgets.get(mindName);
-      if (state) state.queue.push(...messages2);
+      if (state) state.queue.push(...messages);
     }
   }
 };
-var instance6 = null;
+var instance5 = null;
 function initTokenBudget() {
-  if (instance6) throw new Error("TokenBudget already initialized");
-  instance6 = new TokenBudget();
-  return instance6;
+  if (instance5) throw new Error("TokenBudget already initialized");
+  instance5 = new TokenBudget();
+  return instance5;
 }
 function getTokenBudget() {
-  if (!instance6) throw new Error("TokenBudget not initialized \u2014 call initTokenBudget() first");
-  return instance6;
+  if (!instance5) throw new Error("TokenBudget not initialized \u2014 call initTokenBudget() first");
+  return instance5;
 }
 
 // src/lib/daemon/mind-service.ts
 async function startMindFull(name) {
-  const [baseName, variantName] = name.split("@", 2);
+  const entry = await findMind(name);
+  const baseName = entry?.parent ?? name;
   await getMindManager().startMind(name);
   publish({
     type: "mind_started",
     mind: name,
     summary: `${name} started`
   }).catch((err) => logger_default.error("failed to publish mind_started activity", logger_default.errorData(err)));
-  if (variantName) return;
-  const entry = findMind(baseName);
+  if (entry?.parent) return;
   if (!entry || entry.stage === "seed") return;
   const dir = mindDir(baseName);
-  const daemonPort = process.env.VOLUTE_DAEMON_PORT ? parseInt(process.env.VOLUTE_DAEMON_PORT, 10) : void 0;
-  await getConnectorManager().startConnectors(baseName, dir, entry.port, daemonPort);
   getScheduler().loadSchedules(baseName);
   ensureMailAddress(baseName).catch(
     (err) => logger_default.error(`failed to ensure mail address for ${baseName}`, logger_default.errorData(err))
@@ -2729,6 +2089,9 @@ async function startMindFull(name) {
       (err) => logger_default.error(`failed to sync profile for ${baseName}`, logger_default.errorData(err))
     );
   }
+  joinSystemChannelForMind(baseName).catch(
+    (err) => logger_default.error(`failed to join #system for ${baseName}`, logger_default.errorData(err))
+  );
   if (config?.tokenBudget) {
     getTokenBudget().setBudget(
       baseName,
@@ -2756,11 +2119,11 @@ async function wakeMind(name) {
   }).catch((err) => logger_default.error("failed to publish mind_waking activity", logger_default.errorData(err)));
 }
 async function stopMindFull(name) {
-  const [baseName, variantName] = name.split("@", 2);
-  if (!variantName) {
+  const baseName = await getBaseName(name);
+  const isBase = baseName === name;
+  if (isBase) {
     stopWatcher(baseName);
     markIdle(baseName);
-    await getConnectorManager().stopConnectors(baseName);
     getScheduler().unloadSchedules(baseName);
     getTokenBudget().removeBudget(baseName);
   }
@@ -2773,7 +2136,7 @@ async function stopMindFull(name) {
 }
 
 // src/lib/daemon/sleep-manager.ts
-var slog3 = logger_default.child("sleep");
+var slog2 = logger_default.child("sleep");
 function defaultState() {
   return {
     sleeping: false,
@@ -2781,7 +2144,8 @@ function defaultState() {
     scheduledWakeAt: null,
     wokenByTrigger: false,
     voluntaryWakeAt: null,
-    queuedMessageCount: 0
+    queuedMessageCount: 0,
+    triggerWakeHistory: []
   };
 }
 function formatCurrentDate() {
@@ -2809,7 +2173,7 @@ var SleepManager = class {
   unsubActivity = null;
   transitioning = /* @__PURE__ */ new Set();
   get statePath() {
-    return resolve8(voluteHome(), "sleep-state.json");
+    return resolve8(voluteSystemDir(), "sleep-state.json");
   }
   start() {
     this.loadState();
@@ -2828,11 +2192,12 @@ var SleepManager = class {
       if (existsSync5(this.statePath)) {
         const data = JSON.parse(readFileSync5(this.statePath, "utf-8"));
         for (const [name, state] of Object.entries(data)) {
+          state.triggerWakeHistory ??= [];
           this.states.set(name, state);
         }
       }
     } catch (err) {
-      slog3.warn("failed to load sleep state", logger_default.errorData(err));
+      slog2.warn("failed to load sleep state", logger_default.errorData(err));
     }
   }
   saveState() {
@@ -2841,10 +2206,10 @@ var SleepManager = class {
       if (state.sleeping) data[name] = state;
     }
     try {
-      writeFileSync3(this.statePath, `${JSON.stringify(data, null, 2)}
+      writeFileSync4(this.statePath, `${JSON.stringify(data, null, 2)}
 `);
     } catch (err) {
-      slog3.error("failed to save sleep state", logger_default.errorData(err));
+      slog2.error("failed to save sleep state", logger_default.errorData(err));
     }
   }
   // --- Public API ---
@@ -2857,6 +2222,16 @@ var SleepManager = class {
   getState(name) {
     return this.states.get(name) ?? defaultState();
   }
+  /**
+   * Convert a trigger-wake into a full wake. The mind is already running;
+   * this just clears the sleep state so onActivityEvent won't return it to sleep.
+   */
+  convertTriggerToFullWake(name) {
+    const state = this.states.get(name);
+    if (!state?.sleeping || !state.wokenByTrigger) return;
+    this.markAwake(name);
+    slog2.info(`${name} trigger-wake converted to full wake`);
+  }
   getSleepConfig(name) {
     const dir = mindDir(name);
     const config = readVoluteConfig(dir);
@@ -2876,7 +2251,7 @@ var SleepManager = class {
         this.markSleeping(name, opts);
         return;
       }
-      const entry = findMind(name);
+      const entry = await findMind(name);
       if (!entry) return;
       const sleepConfig = this.getSleepConfig(name);
       const wakeTime = opts?.voluntaryWakeAt ?? this.getNextWakeTime(sleepConfig) ?? "scheduled time";
@@ -2891,7 +2266,7 @@ var SleepManager = class {
           content: preSleepMsg
         });
       } catch (err) {
-        slog3.error(`failed to persist pre-sleep message for ${name}`, logger_default.errorData(err));
+        slog2.error(`failed to persist pre-sleep message for ${name}`, logger_default.errorData(err));
       }
       try {
         await fetch(`http://127.0.0.1:${entry.port}/message`, {
@@ -2903,7 +2278,7 @@ var SleepManager = class {
           })
         });
       } catch (err) {
-        slog3.warn(`failed to send pre-sleep message to ${name}`, logger_default.errorData(err));
+        slog2.warn(`failed to send pre-sleep message to ${name}`, logger_default.errorData(err));
       }
       await this.waitForIdle(name, 12e4);
       await new Promise((r) => setTimeout(r, 3e3));
@@ -2911,7 +2286,7 @@ var SleepManager = class {
       await this.killOrphanOnPort(entry.port);
       await this.archiveSessions(name);
       this.markSleeping(name, opts);
-      slog3.info(`${name} is now sleeping`);
+      slog2.info(`${name} is now sleeping`);
     } finally {
       this.transitioning.delete(name);
     }
@@ -2925,72 +2300,76 @@ var SleepManager = class {
     if (this.transitioning.has(name)) return;
     this.transitioning.add(name);
     try {
-      const sleepingSince = state.sleepingSince ? new Date(state.sleepingSince) : /* @__PURE__ */ new Date();
-      const now = /* @__PURE__ */ new Date();
-      const duration = formatDuration(sleepingSince, now);
-      const currentDate = formatCurrentDate();
-      const sleepTime = sleepingSince.toLocaleTimeString("en-US", {
-        hour: "numeric",
-        minute: "2-digit"
-      });
-      const queuedSummary = await this.buildQueuedSummary(name);
       try {
         await wakeMind(name);
       } catch (err) {
-        slog3.error(`failed to wake ${name}`, logger_default.errorData(err));
+        slog2.error(`failed to wake ${name}`, logger_default.errorData(err));
         return;
       }
-      const entry = findMind(name);
+      const entry = await findMind(name);
       if (!entry) return;
-      let summaryText;
       if (opts?.trigger) {
         state.wokenByTrigger = true;
-        summaryText = await getPrompt("wake_trigger_summary", {
-          currentDate,
-          triggerChannel: opts.trigger.channel,
-          sleepTime,
-          duration,
-          queuedSummary
+        state.triggerWakeHistory.push({
+          channel: opts.trigger.channel,
+          at: (/* @__PURE__ */ new Date()).toISOString()
         });
+        this.saveState();
       } else {
-        summaryText = await getPrompt("wake_summary", {
+        const sleepingSince = state.sleepingSince ? new Date(state.sleepingSince) : /* @__PURE__ */ new Date();
+        const now = /* @__PURE__ */ new Date();
+        const duration = formatDuration(sleepingSince, now);
+        const currentDate = formatCurrentDate();
+        const sleepTime = sleepingSince.toLocaleTimeString("en-US", {
+          hour: "numeric",
+          minute: "2-digit"
+        });
+        const triggerWakeSummary = this.buildTriggerWakeSummary(state);
+        const wakeContext = await this.runWakeContextScript(
+          name,
+          state.sleepingSince ?? sleepingSince.toISOString(),
+          duration
+        );
+        const queuedSummary = await this.buildQueuedSummary(name);
+        const sleepActivity = [triggerWakeSummary, wakeContext, queuedSummary].filter(Boolean).join("\n\n");
+        const summaryText = await getPrompt("wake_summary", {
           currentDate,
           sleepTime,
           duration,
-          queuedSummary
-        });
-      }
-      try {
-        const db = await getDb();
-        await db.insert(mindHistory).values({
-          mind: name,
-          type: "inbound",
-          channel: "system:sleep",
-          content: summaryText
+          sleepActivity
         });
-      } catch (err) {
-        slog3.error(`failed to persist wake summary for ${name}`, logger_default.errorData(err));
-      }
-      try {
-        await fetch(`http://127.0.0.1:${entry.port}/message`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            content: [{ type: "text", text: summaryText }],
-            channel: "system:sleep"
-          })
-        });
-      } catch (err) {
-        slog3.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
+        try {
+          const db = await getDb();
+          await db.insert(mindHistory).values({
+            mind: name,
+            type: "inbound",
+            channel: "system:sleep",
+            content: summaryText
+          });
+        } catch (err) {
+          slog2.error(`failed to persist wake summary for ${name}`, logger_default.errorData(err));
+        }
+        try {
+          await fetch(`http://127.0.0.1:${entry.port}/message`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              content: [{ type: "text", text: summaryText }],
+              channel: "system:sleep"
+            })
+          });
+        } catch (err) {
+          slog2.warn(`failed to deliver wake summary to ${name}`, logger_default.errorData(err));
+        }
       }
       const flushed = await this.flushQueuedMessages(name);
       if (flushed > 0) {
-        slog3.info(`flushed ${flushed} queued message(s) for ${name}`);
+        slog2.info(`flushed ${flushed} queued message(s) for ${name}`);
       }
       if (!opts?.trigger) {
         this.markAwake(name);
       }
-      slog3.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
+      slog2.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
     } finally {
       this.transitioning.delete(name);
     }
@@ -3045,16 +2424,16 @@ var SleepManager = class {
   async flushQueuedMessages(name) {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(and4(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select().from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return 0;
-      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-XMGV3FUM.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-LDXLGERA.js");
       const delivered = [];
       for (const row of rows) {
         try {
           await deliverMessage2(name, JSON.parse(row.payload));
           delivered.push(row.id);
         } catch (err) {
-          slog3.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
+          slog2.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
         }
       }
       if (delivered.length > 0) {
@@ -3066,7 +2445,7 @@ var SleepManager = class {
       }
       return delivered.length;
     } catch (err) {
-      slog3.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
+      slog2.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
       return 0;
     }
   }
@@ -3079,7 +2458,8 @@ var SleepManager = class {
       scheduledWakeAt: this.getNextWakeTime(sleepConfig),
       wokenByTrigger: false,
       voluntaryWakeAt: opts?.voluntaryWakeAt ?? null,
-      queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0
+      queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0,
+      triggerWakeHistory: []
     };
     this.states.set(name, state);
     this.saveState();
@@ -3094,14 +2474,14 @@ var SleepManager = class {
       const interval = CronExpressionParser2.parse(config.schedule.wake);
       return interval.next().toDate().toISOString();
     } catch (err) {
-      slog3.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
+      slog2.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
       return null;
     }
   }
-  tick() {
+  async tick() {
     const now = /* @__PURE__ */ new Date();
     const epochMinute = Math.floor(now.getTime() / 6e4);
-    const registry = readRegistry();
+    const registry = await readRegistry();
     for (const entry of registry) {
       if (!entry.running && !this.isSleeping(entry.name)) continue;
       const config = this.getSleepConfig(entry.name);
@@ -3111,7 +2491,7 @@ var SleepManager = class {
         const wakeAt = new Date(state.voluntaryWakeAt);
         if (now >= wakeAt) {
           this.initiateWake(entry.name).catch(
-            (err) => slog3.error(`failed voluntary wake for ${entry.name}`, logger_default.errorData(err))
+            (err) => slog2.error(`failed voluntary wake for ${entry.name}`, logger_default.errorData(err))
           );
           continue;
         }
@@ -3120,7 +2500,7 @@ var SleepManager = class {
         const wakeAt = new Date(state.scheduledWakeAt);
         if (now >= wakeAt) {
           this.initiateWake(entry.name).catch(
-            (err) => slog3.error(`failed scheduled wake for ${entry.name}`, logger_default.errorData(err))
+            (err) => slog2.error(`failed scheduled wake for ${entry.name}`, logger_default.errorData(err))
           );
           continue;
         }
@@ -3128,7 +2508,7 @@ var SleepManager = class {
       if (!state?.sleeping && entry.running) {
         if (this.shouldSleep(config.schedule.sleep, epochMinute)) {
           this.initiateSleep(entry.name).catch(
-            (err) => slog3.error(`failed to initiate sleep for ${entry.name}`, logger_default.errorData(err))
+            (err) => slog2.error(`failed to initiate sleep for ${entry.name}`, logger_default.errorData(err))
           );
         }
       }
@@ -3141,7 +2521,7 @@ var SleepManager = class {
       const prevMinute = Math.floor(prev.getTime() / 6e4);
       return prevMinute === epochMinute;
     } catch (err) {
-      slog3.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
+      slog2.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
       return false;
     }
   }
@@ -3167,7 +2547,7 @@ var SleepManager = class {
     const sessionsDir = resolve8(dir, ".mind", "sessions");
     if (existsSync5(sessionsDir)) {
       const archiveDir = resolve8(sessionsDir, "archive");
-      mkdirSync3(archiveDir, { recursive: true });
+      mkdirSync4(archiveDir, { recursive: true });
       for (const file of readdirSync2(sessionsDir)) {
         if (file === "archive" || !file.endsWith(".json")) continue;
         const src = resolve8(sessionsDir, file);
@@ -3176,14 +2556,14 @@ var SleepManager = class {
         try {
           renameSync(src, dest);
         } catch (err) {
-          slog3.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
+          slog2.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
         }
       }
     }
     const piSessionsDir = resolve8(dir, ".mind", "pi-sessions");
     if (existsSync5(piSessionsDir)) {
       const archiveDir = resolve8(piSessionsDir, "archive");
-      mkdirSync3(archiveDir, { recursive: true });
+      mkdirSync4(archiveDir, { recursive: true });
       for (const entry of readdirSync2(piSessionsDir, { withFileTypes: true })) {
         if (entry.name === "archive" || !entry.isDirectory()) continue;
         const src = resolve8(piSessionsDir, entry.name);
@@ -3191,25 +2571,77 @@ var SleepManager = class {
         try {
           renameSync(src, dest);
         } catch (err) {
-          slog3.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
+          slog2.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
         }
       }
     }
   }
+  async runWakeContextScript(name, sleepingSince, duration) {
+    const scriptPath = resolve8(mindDir(name), "home", ".config", "hooks", "wake-context.sh");
+    if (!existsSync5(scriptPath)) return "";
+    const input = JSON.stringify({
+      sleepingSince,
+      duration,
+      wakeTime: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      const result = await new Promise((resolvePromise, reject) => {
+        const child = spawnChild("bash", [scriptPath], {
+          cwd: mindDir(name),
+          timeout: 5e3,
+          env: { ...process.env, VOLUTE_MIND: name },
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+        child.on("close", (code) => {
+          if (code === 0) resolvePromise(stdout);
+          else
+            reject(
+              new Error(
+                `wake-context script exited with code ${code}${stderr ? `: ${stderr.trim()}` : ""}`
+              )
+            );
+        });
+        child.on("error", reject);
+        child.stdin.end(input);
+      });
+      return result.trim();
+    } catch (err) {
+      slog2.warn(`wake-context script failed for ${name}`, logger_default.errorData(err));
+      return "";
+    }
+  }
+  buildTriggerWakeSummary(state) {
+    const history = state.triggerWakeHistory;
+    if (!history || history.length === 0) return "";
+    const channels = [...new Set(history.map((h) => h.channel))];
+    const times = history.length === 1 ? "once" : `${history.length} times`;
+    return `You were briefly woken ${times} during sleep to handle messages on ${channels.join(", ")} (sessions were archived after each).`;
+  }
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel }).from(deliveryQueue).where(and4(eq4(deliveryQueue.mind, name), eq4(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return "No messages arrived while you slept.";
       const channelCounts = /* @__PURE__ */ new Map();
+      const senders = /* @__PURE__ */ new Set();
       for (const row of rows) {
         const ch = row.channel ?? "unknown";
         channelCounts.set(ch, (channelCounts.get(ch) ?? 0) + 1);
+        if (row.sender) senders.add(row.sender);
       }
       const parts = [...channelCounts.entries()].map(([ch, count2]) => `${count2} on ${ch}`);
-      return `${rows.length} message${rows.length === 1 ? "" : "s"} arrived while you slept (${parts.join(", ")}). They'll be delivered to your normal channels now.`;
+      const senderNote = senders.size > 0 ? ` from ${[...senders].join(", ")}` : "";
+      return `${rows.length} message${rows.length === 1 ? "" : "s"} arrived while you slept${senderNote} (${parts.join(", ")}). They'll be delivered to your normal channels now.`;
     } catch (err) {
-      slog3.error(`failed to build queued summary for ${name}`, logger_default.errorData(err));
+      slog2.error(`failed to build queued summary for ${name}`, logger_default.errorData(err));
       return "Unable to check for queued messages \u2014 there may be messages waiting.";
     }
   }
@@ -3224,7 +2656,7 @@ var SleepManager = class {
     } catch {
       return;
     }
-    slog3.warn(`orphan process found on port ${port} after sleep, killing`);
+    slog2.warn(`orphan process found on port ${port} after sleep, killing`);
     const execFileAsync = promisify(execFile);
     try {
       const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
@@ -3235,7 +2667,7 @@ var SleepManager = class {
             process.kill(pid, "SIGTERM");
           } catch (err) {
             if (err.code !== "ESRCH") {
-              slog3.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
+              slog2.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
             }
           }
         }
@@ -3267,7 +2699,7 @@ var SleepManager = class {
           }
         }
       } catch (err) {
-        slog3.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
+        slog2.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
       }
     }
     await new Promise((r) => setTimeout(r, 1e3));
@@ -3277,7 +2709,7 @@ var SleepManager = class {
     if (!state?.sleeping || !state.wokenByTrigger) return;
     if (this.transitioning.has(event.mind)) return;
     if (event.type === "mind_idle") {
-      slog3.info(`${event.mind} going back to sleep after trigger wake`);
+      slog2.info(`${event.mind} going back to sleep after trigger wake`);
       state.wokenByTrigger = false;
       this.transitioning.add(event.mind);
       sleepMind(event.mind).then(() => this.archiveSessions(event.mind)).then(() => {
@@ -3286,32 +2718,30 @@ var SleepManager = class {
         const sleepConfig = this.getSleepConfig(event.mind);
         state.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
         this.saveState();
-        slog3.info(`${event.mind} returned to sleep`);
+        slog2.info(`${event.mind} returned to sleep`);
       }).catch((err) => {
-        slog3.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
+        slog2.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
       }).finally(() => {
         this.transitioning.delete(event.mind);
       });
     }
   }
 };
-var instance7 = null;
+var instance6 = null;
 function initSleepManager() {
-  if (instance7) throw new Error("SleepManager already initialized");
-  instance7 = new SleepManager();
-  return instance7;
+  if (instance6) throw new Error("SleepManager already initialized");
+  instance6 = new SleepManager();
+  return instance6;
 }
 function getSleepManager() {
-  if (!instance7) throw new Error("SleepManager not initialized \u2014 call initSleepManager() first");
-  return instance7;
+  if (!instance6) throw new Error("SleepManager not initialized \u2014 call initSleepManager() first");
+  return instance6;
 }
 function getSleepManagerIfReady() {
-  return instance7;
+  return instance6;
 }
 
 export {
-  initConnectorManager,
-  getConnectorManager,
   createUser,
   verifyUser,
   getUser,
@@ -3327,9 +2757,18 @@ export {
   setUserRole,
   deleteUser,
   updateUserProfile,
+  migrateMindRoles,
+  readVoluteConfig,
+  writeVoluteConfig,
   stopAllWatchers,
   getCachedSites,
   getCachedRecentPages,
+  splitMessage,
+  writeChannelEntry,
+  resolveChannelId,
+  ensureSystemChannel,
+  joinSystemChannel,
+  announceToSystem,
   initScheduler,
   getScheduler,
   initTokenBudget,
@@ -3342,32 +2781,7 @@ export {
   getSleepManager,
   getSleepManagerIfReady,
   subscribe2 as subscribe,
-  publish2 as publish,
-  getWebhookUrl,
-  getAuthHeaders,
-  fireWebhook,
-  initWebhook,
-  subscribe3 as subscribe2,
-  publish3 as publish2,
-  createConversation,
-  getConversation,
-  getParticipants,
-  isParticipant,
-  listConversationsForUser,
-  isParticipantOrOwner,
-  deleteConversationForUser,
-  addMessage,
-  getMessages,
-  getMessagesPaginated,
-  listConversationsWithParticipants,
-  findDMConversation,
-  createChannel,
-  getChannelByName,
-  listChannels,
-  joinChannel,
-  leaveChannel,
-  getUnreadCounts,
-  markConversationRead,
+  publish3 as publish,
   getTypingMap,
   publishTypingForChannels,
   extractTextContent,
@@ -3375,6 +2789,5 @@ export {
   getDeliveryManager,
   recordInbound,
   deliverMessage,
-  initMailPoller,
-  getMailPoller
+  initMailPoller
 };