volute 0.20.0 → 0.22.0

package/dist/chunk-OSFGKF2T.js

@@ -0,0 +1,2651 @@
+#!/usr/bin/env node
+import {
+  readSystemsConfig
+} from "./chunk-HFCBO2GL.js";
+import {
+  markIdle
+} from "./chunk-HGCDWKSP.js";
+import {
+  publish,
+  subscribe
+} from "./chunk-A4S7H6G6.js";
+import {
+  RestartTracker,
+  RotatingLog,
+  clearJsonMap,
+  getMindManager,
+  getPrompt,
+  loadJsonMap,
+  saveJsonMap
+} from "./chunk-VNVCRVYI.js";
+import {
+  readVoluteConfig
+} from "./chunk-XLC342FO.js";
+import {
+  loadMergedEnv
+} from "./chunk-PHU4DEAJ.js";
+import {
+  deliveryQueue,
+  getDb,
+  mindHistory
+} from "./chunk-SGPEZ32F.js";
+import {
+  logger_default
+} from "./chunk-YUIHSKR6.js";
+import {
+  exec
+} from "./chunk-JTDFJWI2.js";
+import {
+  chownMindDir,
+  isIsolationEnabled,
+  wrapForIsolation
+} from "./chunk-NWPT4ASZ.js";
+import {
+  daemonLoopback,
+  findMind,
+  findVariant,
+  mindDir,
+  readRegistry,
+  stateDir,
+  voluteHome
+} from "./chunk-B2CPS4QU.js";
+
+// src/lib/daemon/sleep-manager.ts
+import { execFile } from "child_process";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  readlinkSync,
+  renameSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { resolve as resolve7 } from "path";
+import { promisify } from "util";
+import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
+import { and as and2, eq as eq2, inArray } from "drizzle-orm";
+
+// src/lib/pages-watcher.ts
+import { existsSync, readdirSync, statSync, watch } from "fs";
+import { join, resolve } from "path";
+var watchers = /* @__PURE__ */ new Map();
+var homeWatchers = /* @__PURE__ */ new Map();
+var debounceTimers = /* @__PURE__ */ new Map();
+var sitesCache = null;
+var recentPagesCache = null;
+function startPagesWatcher(mindName, pagesDir) {
+  try {
+    const watcher = watch(pagesDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename || !filename.endsWith(".html")) return;
+      const key = `${mindName}:${filename}`;
+      const existing = debounceTimers.get(key);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(
+        key,
+        setTimeout(() => {
+          debounceTimers.delete(key);
+          invalidateCache();
+          publish({
+            type: "page_updated",
+            mind: mindName,
+            summary: `${mindName} updated ${filename}`,
+            metadata: { file: filename }
+          }).catch(
+            (err) => logger_default.error("failed to publish page_updated activity", logger_default.errorData(err))
+          );
+        }, 100)
+      );
+    });
+    watchers.set(mindName, watcher);
+  } catch (err) {
+    logger_default.warn(`failed to start pages watcher for ${mindName}`, logger_default.errorData(err));
+  }
+}
+function startWatcher(mindName) {
+  if (watchers.has(mindName)) return;
+  const pagesDir = resolve(mindDir(mindName), "home", "pages");
+  if (existsSync(pagesDir)) {
+    startPagesWatcher(mindName, pagesDir);
+    return;
+  }
+  if (homeWatchers.has(mindName)) return;
+  const homeDir = resolve(mindDir(mindName), "home");
+  if (!existsSync(homeDir)) return;
+  try {
+    const hw = watch(homeDir, (_eventType, filename) => {
+      if (filename !== "pages") return;
+      if (!existsSync(pagesDir)) return;
+      hw.close();
+      homeWatchers.delete(mindName);
+      invalidateCache();
+      startPagesWatcher(mindName, pagesDir);
+    });
+    homeWatchers.set(mindName, hw);
+  } catch (err) {
+    logger_default.warn(`failed to start home watcher for ${mindName}`, logger_default.errorData(err));
+  }
+}
+function stopWatcher(mindName) {
+  const watcher = watchers.get(mindName);
+  if (watcher) {
+    watcher.close();
+    watchers.delete(mindName);
+  }
+  const hw = homeWatchers.get(mindName);
+  if (hw) {
+    hw.close();
+    homeWatchers.delete(mindName);
+  }
+  for (const [key, timer] of debounceTimers) {
+    if (key.startsWith(`${mindName}:`)) {
+      clearTimeout(timer);
+      debounceTimers.delete(key);
+    }
+  }
+}
+function stopAllWatchers() {
+  for (const [, watcher] of watchers) {
+    watcher.close();
+  }
+  watchers.clear();
+  for (const [, hw] of homeWatchers) {
+    hw.close();
+  }
+  homeWatchers.clear();
+  for (const [, timer] of debounceTimers) {
+    clearTimeout(timer);
+  }
+  debounceTimers.clear();
+  invalidateCache();
+}
+function invalidateCache() {
+  sitesCache = null;
+  recentPagesCache = null;
+}
+function scanPagesDir(dir, urlPrefix) {
+  const pages = [];
+  let items;
+  try {
+    items = readdirSync(dir);
+  } catch {
+    return pages;
+  }
+  for (const item of items) {
+    if (item.startsWith(".")) continue;
+    const fullPath = resolve(dir, item);
+    try {
+      const s = statSync(fullPath);
+      if (s.isFile() && item.endsWith(".html")) {
+        pages.push({
+          file: item,
+          modified: s.mtime.toISOString(),
+          url: `${urlPrefix}/${item}`
+        });
+      } else if (s.isDirectory()) {
+        const indexPath = resolve(fullPath, "index.html");
+        if (existsSync(indexPath)) {
+          const indexStat = statSync(indexPath);
+          pages.push({
+            file: join(item, "index.html"),
+            modified: indexStat.mtime.toISOString(),
+            url: `${urlPrefix}/${item}/`
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+  return pages;
+}
+function buildSites() {
+  const sites = [];
+  const systemPagesDir = resolve(voluteHome(), "shared", "pages");
+  if (existsSync(systemPagesDir)) {
+    const systemPages = scanPagesDir(systemPagesDir, "/pages/_system");
+    if (systemPages.length > 0) {
+      sites.push({ name: "_system", label: "System", pages: systemPages });
+    }
+  }
+  const entries = readRegistry();
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    const pagesDir = resolve(mindDir(entry.name), "home", "pages");
+    if (!existsSync(pagesDir)) continue;
+    const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
+    if (mindPages.length > 0) {
+      sites.push({ name: entry.name, label: entry.name, pages: mindPages });
+    }
+  }
+  return sites;
+}
+function buildRecentPages() {
+  const entries = readRegistry();
+  const pages = [];
+  for (const entry of entries) {
+    const pagesDir = resolve(mindDir(entry.name), "home", "pages");
+    if (!existsSync(pagesDir)) continue;
+    let items;
+    try {
+      items = readdirSync(pagesDir);
+    } catch {
+      continue;
+    }
+    for (const item of items) {
+      if (item.startsWith(".")) continue;
+      const fullPath = resolve(pagesDir, item);
+      try {
+        const s = statSync(fullPath);
+        if (s.isFile() && item.endsWith(".html")) {
+          pages.push({
+            mind: entry.name,
+            file: item,
+            modified: s.mtime.toISOString(),
+            url: `/pages/${entry.name}/${item}`
+          });
+        } else if (s.isDirectory()) {
+          const indexPath = resolve(fullPath, "index.html");
+          if (existsSync(indexPath)) {
+            const indexStat = statSync(indexPath);
+            pages.push({
+              mind: entry.name,
+              file: join(item, "index.html"),
+              modified: indexStat.mtime.toISOString(),
+              url: `/pages/${entry.name}/${item}/`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  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();
+  return sitesCache;
+}
+function getCachedRecentPages() {
+  if (!recentPagesCache) recentPagesCache = 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;
+      }
+    }
+  }
+  return null;
+}
+function checkMissingEnvVars(def, env) {
+  return def.envVars.filter((v) => v.required && !env[v.name]);
+}
+
+// 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((resolve8) => {
+      tracked.child.on("exit", () => resolve8());
+      try {
+        process.kill(-tracked.child.pid, "SIGTERM");
+      } catch {
+        resolve8();
+      }
+      setTimeout(() => {
+        try {
+          process.kill(-tracked.child.pid, "SIGKILL");
+        } catch {
+        }
+        resolve8();
+      }, 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 {
+    }
+  }
+  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;
+}
+
+// src/lib/delivery/delivery-manager.ts
+import { and, eq, sql } from "drizzle-orm";
+
+// src/lib/events/conversation-events.ts
+var subscribers = /* @__PURE__ */ new Map();
+function subscribe2(conversationId, callback) {
+  let set = subscribers.get(conversationId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(conversationId, set);
+  }
+  set.add(callback);
+  return () => {
+    set.delete(callback);
+    if (set.size === 0) subscribers.delete(conversationId);
+  };
+}
+function publish2(conversationId, event) {
+  const set = subscribers.get(conversationId);
+  if (!set) return;
+  for (const cb of set) {
+    try {
+      cb(event);
+    } catch (err) {
+      console.error("[conversation-events] subscriber threw:", err);
+      set.delete(cb);
+      if (set.size === 0) subscribers.delete(conversationId);
+    }
+  }
+}
+
+// src/lib/typing.ts
+var DEFAULT_TTL_MS = 1e4;
+var SWEEP_INTERVAL_MS = 5e3;
+var VOLUTE_PREFIX = "volute:";
+var TypingMap = class {
+  channels = /* @__PURE__ */ new Map();
+  sweepTimer;
+  constructor() {
+    this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
+    this.sweepTimer.unref();
+  }
+  set(channel, sender, opts) {
+    const expiresAt = opts?.persistent ? Infinity : Date.now() + (opts?.ttlMs ?? DEFAULT_TTL_MS);
+    let senders = this.channels.get(channel);
+    if (!senders) {
+      senders = /* @__PURE__ */ new Map();
+      this.channels.set(channel, senders);
+    }
+    senders.set(sender, { expiresAt });
+  }
+  delete(channel, sender) {
+    const senders = this.channels.get(channel);
+    if (senders) {
+      senders.delete(sender);
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+  }
+  /** Remove a sender from all channels (e.g. when a mind finishes processing). Returns affected channel names. */
+  deleteSender(sender) {
+    const affected = [];
+    for (const [channel, senders] of this.channels) {
+      if (senders.has(sender)) {
+        senders.delete(sender);
+        affected.push(channel);
+      }
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+    return affected;
+  }
+  get(channel) {
+    const senders = this.channels.get(channel);
+    if (!senders) return [];
+    const now = Date.now();
+    const result = [];
+    for (const [sender, entry] of senders) {
+      if (entry.expiresAt > now) {
+        result.push(sender);
+      }
+    }
+    return result;
+  }
+  dispose() {
+    clearInterval(this.sweepTimer);
+    this.channels.clear();
+    if (instance2 === this) instance2 = void 0;
+  }
+  sweep() {
+    const now = Date.now();
+    for (const [channel, senders] of this.channels) {
+      for (const [sender, entry] of senders) {
+        if (entry.expiresAt <= now) {
+          senders.delete(sender);
+        }
+      }
+      if (senders.size === 0) {
+        this.channels.delete(channel);
+      }
+    }
+  }
+};
+var instance2;
+function getTypingMap() {
+  if (!instance2) {
+    instance2 = new TypingMap();
+  }
+  return instance2;
+}
+function publishTypingForChannels(channels, map) {
+  for (const channel of channels) {
+    if (channel.startsWith(VOLUTE_PREFIX)) {
+      const conversationId = channel.slice(VOLUTE_PREFIX.length);
+      publish2(conversationId, { type: "typing", senders: map.get(channel) });
+    }
+  }
+}
+
+// src/lib/delivery/delivery-router.ts
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p.type === "text" && p.text).map((p) => p.text).join("\n");
+  }
+  return JSON.stringify(content);
+}
+var configCache = /* @__PURE__ */ new Map();
+var statCheckCache = /* @__PURE__ */ new Map();
+var STAT_TTL_MS = 5e3;
+var dlog = logger_default.child("delivery-router");
+function configPath(mindName) {
+  return resolve4(mindDir(mindName), "home/.config/routes.json");
+}
+function getRoutingConfig(mindName) {
+  const path = configPath(mindName);
+  const now = Date.now();
+  const statCached = statCheckCache.get(mindName);
+  const cached = configCache.get(mindName);
+  if (statCached && cached && now - statCached.checkedAt < STAT_TTL_MS) {
+    return cached.config;
+  }
+  let mtime;
+  try {
+    mtime = statSync2(path).mtimeMs;
+  } catch {
+    configCache.delete(mindName);
+    statCheckCache.delete(mindName);
+    return {};
+  }
+  statCheckCache.set(mindName, { mtime, checkedAt: now });
+  if (cached && cached.mtime === mtime) {
+    return cached.config;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    const config = Array.isArray(parsed) ? { rules: parsed } : parsed;
+    configCache.set(mindName, { config, mtime });
+    return config;
+  } catch (err) {
+    dlog.warn(`failed to load routes.json for ${mindName}`, logger_default.errorData(err));
+    configCache.delete(mindName);
+    return {};
+  }
+}
+var globRegexCache = /* @__PURE__ */ new Map();
+function globMatch(pattern, value) {
+  let regex = globRegexCache.get(pattern);
+  if (!regex) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    regex = new RegExp(`^${escaped}$`);
+    globRegexCache.set(pattern, regex);
+  }
+  return regex.test(value);
+}
+var GLOB_MATCH_KEYS = /* @__PURE__ */ new Set(["channel", "sender"]);
+var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode"]);
+function ruleMatches(rule, meta) {
+  for (const [key, pattern] of Object.entries(rule)) {
+    if (NON_MATCH_KEYS.has(key)) continue;
+    if (key === "isDM") {
+      if (typeof pattern !== "boolean") return false;
+      if ((meta.isDM ?? false) !== pattern) return false;
+      continue;
+    }
+    if (key === "participants") {
+      if (typeof pattern !== "number") return false;
+      if ((meta.participantCount ?? 0) !== pattern) return false;
+      continue;
+    }
+    if (typeof pattern !== "string") return false;
+    if (!GLOB_MATCH_KEYS.has(key)) return false;
+    const value = meta[key] ?? "";
+    if (!globMatch(pattern, value)) return false;
+  }
+  return true;
+}
+function expandTemplate(template, meta) {
+  return template.replace(/\$\{sender\}/g, meta.sender ?? "unknown").replace(/\$\{channel\}/g, meta.channel ?? "unknown");
+}
+function sanitizeSessionName(name) {
+  return name.replace(/\0/g, "").replace(/[/\\]/g, "-").replace(/\.\./g, "-").slice(0, 100);
+}
+function resolveRoute(config, meta) {
+  const fallback = config.default ?? "main";
+  if (!config.rules) {
+    return { destination: "mind", session: fallback, matched: false };
+  }
+  for (const rule of config.rules) {
+    if (ruleMatches(rule, meta)) {
+      if (rule.destination === "file") {
+        if (!rule.path) {
+          dlog.warn("file destination rule missing path \u2014 falling through");
+          continue;
+        }
+        return { destination: "file", path: rule.path, matched: true };
+      }
+      return {
+        destination: "mind",
+        session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
+        matched: true,
+        mode: rule.mode
+      };
+    }
+  }
+  return { destination: "mind", session: fallback, matched: false };
+}
+var DEFAULT_BATCH_DEBOUNCE = 5;
+var DEFAULT_BATCH_MAX_WAIT = 120;
+function normalizeBatchConfig(batch) {
+  if (typeof batch === "number") return { maxWait: batch * 60 };
+  return batch;
+}
+function resolveDeliveryMode(config, sessionName) {
+  const defaults = {
+    delivery: { mode: "immediate" },
+    interrupt: true
+  };
+  if (!config.sessions) return defaults;
+  for (const [pattern, sessionConfig] of Object.entries(config.sessions)) {
+    if (globMatch(pattern, sessionName)) {
+      let delivery;
+      if (sessionConfig.delivery != null) {
+        if (sessionConfig.delivery === "immediate") {
+          delivery = { mode: "immediate" };
+        } else if (sessionConfig.delivery === "batch") {
+          delivery = {
+            mode: "batch",
+            debounce: DEFAULT_BATCH_DEBOUNCE,
+            maxWait: DEFAULT_BATCH_MAX_WAIT
+          };
+        } else {
+          delivery = {
+            mode: "batch",
+            debounce: sessionConfig.delivery.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+            maxWait: sessionConfig.delivery.maxWait ?? DEFAULT_BATCH_MAX_WAIT
+          };
+        }
+      } else if (sessionConfig.batch != null) {
+        const batch = normalizeBatchConfig(sessionConfig.batch);
+        delivery = {
+          mode: "batch",
+          debounce: batch.debounce ?? DEFAULT_BATCH_DEBOUNCE,
+          maxWait: batch.maxWait ?? DEFAULT_BATCH_MAX_WAIT,
+          triggers: batch.triggers
+        };
+      } else if (sessionConfig.interrupt === false) {
+        delivery = {
+          mode: "batch",
+          debounce: DEFAULT_BATCH_DEBOUNCE,
+          maxWait: DEFAULT_BATCH_MAX_WAIT
+        };
+      } else {
+        delivery = { mode: "immediate" };
+      }
+      return {
+        delivery,
+        interrupt: sessionConfig.interrupt ?? true,
+        instructions: sessionConfig.instructions
+      };
+    }
+  }
+  return defaults;
+}
+
+// src/lib/delivery/delivery-manager.ts
+var dlog2 = logger_default.child("delivery-manager");
+var MAX_BATCH_SIZE = 50;
+var DeliveryManager = class {
+  sessionStates = /* @__PURE__ */ new Map();
+  batchBuffers = /* @__PURE__ */ new Map();
+  // --- Public API ---
+  /**
+   * Route and deliver a message to a mind. This is the main entry point.
+   * The message is routed via the mind's routes.json, then either delivered immediately
+   * or queued for batching depending on the session's delivery mode.
+   */
+  async routeAndDeliver(mindName, payload) {
+    const [baseName] = mindName.split("@", 2);
+    const config = getRoutingConfig(baseName);
+    const meta = {
+      channel: payload.channel,
+      sender: payload.sender ?? void 0,
+      isDM: payload.isDM,
+      participantCount: payload.participantCount
+    };
+    const route = resolveRoute(config, meta);
+    dlog2.debug(
+      `route for ${mindName} ch=${payload.channel}: dest=${route.destination} matched=${route.matched}`
+    );
+    if (route.destination === "file") {
+      return { routed: true, session: route.path, destination: "file", mode: "immediate" };
+    }
+    if (!route.matched && config.gateUnmatched !== false) {
+      dlog2.debug(`gating unmatched channel ${payload.channel} for ${mindName}`);
+      await this.gateMessage(mindName, route.session, payload);
+      return { routed: true, session: route.session, destination: "mind", mode: "gated" };
+    }
+    if (route.mode === "mention" && payload.sender) {
+      const text = extractTextContent(payload.content);
+      const escaped = baseName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pattern = new RegExp(`\\b${escaped}\\b`, "i");
+      if (!pattern.test(text)) {
+        dlog2.debug(`mention-filtered message on ${payload.channel} for ${mindName}`);
+        return { routed: false, reason: "mention-filtered" };
+      }
+    }
+    let sessionName = route.session;
+    if (sessionName === "$new") {
+      sessionName = `new-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    }
+    const sessionConfig = resolveDeliveryMode(config, sessionName);
+    if (sessionConfig.delivery.mode === "batch") {
+      dlog2.debug(`enqueueing batch message for ${mindName}/${sessionName}`);
+      this.enqueueBatch(mindName, sessionName, payload, sessionConfig);
+      return { routed: true, session: sessionName, destination: "mind", mode: "batch" };
+    }
+    await this.deliverToMind(mindName, sessionName, payload, sessionConfig);
+    return { routed: true, session: sessionName, destination: "mind", mode: "immediate" };
+  }
+  /**
+   * 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);
+    if (session) {
+      this.decrementActive(baseName, session);
+    } else {
+      const mindSessions = this.sessionStates.get(baseName);
+      if (mindSessions) {
+        for (const [sessionName] of mindSessions) {
+          this.decrementActive(baseName, sessionName);
+        }
+      }
+    }
+  }
+  /**
+   * Restore queued messages from DB on daemon restart.
+   */
+  async restoreFromDb() {
+    try {
+      const db = await getDb();
+      const rows = await db.select().from(deliveryQueue).where(eq(deliveryQueue.status, "pending"));
+      for (const row of rows) {
+        let payload;
+        try {
+          payload = JSON.parse(row.payload);
+        } catch (parseErr) {
+          dlog2.warn(
+            `corrupt payload in delivery queue row ${row.id}, skipping`,
+            logger_default.errorData(parseErr)
+          );
+          continue;
+        }
+        const config = getRoutingConfig(row.mind);
+        const sessionConfig = resolveDeliveryMode(config, row.session);
+        if (sessionConfig.delivery.mode === "batch") {
+          this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
+        } else {
+          try {
+            await db.delete(deliveryQueue).where(eq(deliveryQueue.id, row.id));
+          } catch (err) {
+            dlog2.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
+          }
+          this.deliverToMind(row.mind, row.session, payload, sessionConfig).catch((err) => {
+            dlog2.warn(`failed to restore delivery for ${row.mind}`, logger_default.errorData(err));
+          });
+        }
+      }
+      if (rows.length > 0) {
+        dlog2.info(`restored ${rows.length} queued messages from DB`);
+      }
+    } catch (err) {
+      dlog2.warn("failed to restore delivery queue from DB", logger_default.errorData(err));
+    }
+  }
+  /**
+   * Get pending (gated) messages for a mind.
+   */
+  async getPending(mindName) {
+    const db = await getDb();
+    const rows = await db.select().from(deliveryQueue).where(and(eq(deliveryQueue.mind, mindName), eq(deliveryQueue.status, "gated")));
+    const byChannel = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const ch = row.channel ?? "unknown";
+      const existing = byChannel.get(ch) ?? [];
+      existing.push(row);
+      byChannel.set(ch, existing);
+    }
+    return [...byChannel.entries()].map(([channel, channelRows]) => {
+      const firstRow = channelRows[0];
+      const payload = JSON.parse(firstRow.payload);
+      const text = extractTextContent(payload.content);
+      return {
+        channel,
+        sender: firstRow.sender,
+        count: channelRows.length,
+        firstSeen: firstRow.created_at,
+        preview: text.length > 200 ? `${text.slice(0, 200)}...` : text
+      };
+    });
+  }
+  /**
+   * Check if a session is currently busy (has active deliveries).
+   */
+  isSessionBusy(mindName, session) {
+    const state = this.sessionStates.get(mindName)?.get(session);
+    return (state?.activeCount ?? 0) > 0;
+  }
+  /**
+   * Cleanup all timers and subscriptions.
+   */
+  dispose() {
+    for (const [, buffer] of this.batchBuffers) {
+      if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+      if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+    }
+    this.batchBuffers.clear();
+    this.sessionStates.clear();
+    if (instance3 === this) instance3 = void 0;
+  }
+  // --- Private ---
+  resolvePort(mindName) {
+    const [baseName, variantName] = mindName.split("@", 2);
+    const entry = findMind(baseName);
+    if (!entry) return null;
+    if (variantName) {
+      const variant = findVariant(baseName, variantName);
+      if (!variant) return null;
+      return { baseName, port: variant.port };
+    }
+    return { baseName, port: entry.port };
+  }
+  async postToMind(port, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        dlog2.warn(`mind responded ${res.status}: ${text}`);
+        return false;
+      }
+      await res.text().catch(() => {
+      });
+      return true;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async deliverToMind(mindName, session, payload, sessionConfig) {
+    const resolved = this.resolvePort(mindName);
+    if (!resolved) {
+      dlog2.warn(`cannot deliver to ${mindName}: mind not found`);
+      return;
+    }
+    const { baseName, port } = resolved;
+    const senders = /* @__PURE__ */ new Set();
+    if (payload.sender) senders.add(payload.sender);
+    const channels = /* @__PURE__ */ new Set();
+    if (payload.channel) channels.add(payload.channel);
+    this.incrementActive(baseName, session, senders, channels);
+    const typingMap = getTypingMap();
+    if (payload.channel) {
+      typingMap.set(payload.channel, baseName, { persistent: true });
+    }
+    if (payload.conversationId) {
+      typingMap.set(`volute:${payload.conversationId}`, baseName, { persistent: true });
+    }
+    const body = JSON.stringify({
+      ...payload,
+      session,
+      interrupt: sessionConfig.interrupt,
+      instructions: sessionConfig.instructions
+    });
+    try {
+      const ok = await this.postToMind(port, body);
+      if (!ok) {
+        this.decrementActive(baseName, session);
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+      }
+    } catch (err) {
+      dlog2.warn(`failed to deliver to ${mindName}`, logger_default.errorData(err));
+      this.decrementActive(baseName, session);
+      publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+    }
+  }
+  async deliverBatchToMind(mindName, session, messages, sessionConfig, interruptOverride) {
+    const resolved = this.resolvePort(mindName);
+    if (!resolved) {
+      dlog2.warn(`cannot deliver batch to ${mindName}: mind not found`);
+      return;
+    }
+    const { baseName, port } = resolved;
+    const channels = {};
+    for (const msg of messages) {
+      const ch = msg.channel ?? "unknown";
+      if (!channels[ch]) channels[ch] = [];
+      channels[ch].push(msg.payload);
+    }
+    const senders = /* @__PURE__ */ new Set();
+    const channelSet = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.sender) senders.add(msg.sender);
+      if (msg.channel) channelSet.add(msg.channel);
+    }
+    this.incrementActive(baseName, session, senders, channelSet);
+    const typingMap = getTypingMap();
+    for (const ch of Object.keys(channels)) {
+      if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
+    }
+    const seenConvIds = /* @__PURE__ */ new Set();
+    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 });
+      }
+    }
+    const body = JSON.stringify({
+      session,
+      batch: { channels },
+      interrupt: interruptOverride ?? sessionConfig.interrupt,
+      instructions: sessionConfig.instructions
+    });
+    try {
+      const ok = await this.postToMind(port, body);
+      if (!ok) {
+        this.decrementActive(baseName, session);
+        publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+      } else {
+        try {
+          const db = await getDb();
+          await db.delete(deliveryQueue).where(
+            and(
+              eq(deliveryQueue.mind, baseName),
+              eq(deliveryQueue.session, session),
+              eq(deliveryQueue.status, "pending")
+            )
+          );
+        } catch (err) {
+          dlog2.warn(
+            `failed to clean delivery queue for ${baseName}/${session}`,
+            logger_default.errorData(err)
+          );
+        }
+      }
+    } catch (err) {
+      dlog2.warn(`failed to deliver batch to ${mindName}`, logger_default.errorData(err));
+      this.decrementActive(baseName, session);
+      publishTypingForChannels(typingMap.deleteSender(baseName), typingMap);
+    }
+  }
+  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, [
+          {
+            payload,
+            channel: payload.channel,
+            sender: payload.sender ?? null,
+            createdAt: Date.now()
+          }
+        ]);
+        return;
+      }
+    }
+    const [baseName] = mindName.split("@", 2);
+    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(
+        mindName,
+        session,
+        [{ payload, channel: payload.channel, sender: payload.sender, createdAt: Date.now() }],
+        true
+      );
+      return;
+    }
+    this.persistToQueue(mindName, session, payload).catch((err) => {
+      dlog2.warn(`failed to persist batch message for ${mindName}/${session}`, logger_default.errorData(err));
+    });
+    this.addToBatchBuffer(mindName, session, payload, sessionConfig);
+  }
+  addToBatchBuffer(mindName, session, payload, sessionConfig) {
+    const delivery = sessionConfig.delivery;
+    const bufferKey = `${mindName}:${session}`;
+    let buffer = this.batchBuffers.get(bufferKey);
+    if (!buffer) {
+      buffer = {
+        messages: [],
+        debounceTimer: null,
+        maxWaitTimer: null,
+        delivery
+      };
+      this.batchBuffers.set(bufferKey, buffer);
+    }
+    buffer.messages.push({
+      payload,
+      channel: payload.channel,
+      sender: payload.sender ?? null,
+      createdAt: Date.now()
+    });
+    if (buffer.messages.length >= MAX_BATCH_SIZE) {
+      this.flushBatch(mindName, session);
+      return;
+    }
+    this.scheduleBatchTimers(mindName, session, bufferKey);
+  }
+  scheduleBatchTimers(mindName, session, bufferKey) {
+    const buffer = this.batchBuffers.get(bufferKey);
+    if (!buffer) return;
+    if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+    buffer.debounceTimer = setTimeout(() => {
+      if (!this.isSessionBusy(mindName, session)) {
+        this.flushBatch(mindName, session);
+      }
+    }, buffer.delivery.debounce * 1e3);
+    buffer.debounceTimer.unref();
+    if (!buffer.maxWaitTimer) {
+      buffer.maxWaitTimer = setTimeout(() => {
+        this.flushBatch(mindName, session);
+      }, buffer.delivery.maxWait * 1e3);
+      buffer.maxWaitTimer.unref();
+    }
+  }
+  flushBatch(mindName, session, extra, interruptOverride) {
+    const bufferKey = `${mindName}:${session}`;
+    const buffer = this.batchBuffers.get(bufferKey);
+    const messages = [];
+    if (buffer) {
+      if (buffer.debounceTimer) clearTimeout(buffer.debounceTimer);
+      if (buffer.maxWaitTimer) clearTimeout(buffer.maxWaitTimer);
+      buffer.debounceTimer = null;
+      buffer.maxWaitTimer = null;
+      messages.push(...buffer.messages.splice(0));
+      this.batchBuffers.delete(bufferKey);
+    }
+    if (extra) messages.push(...extra);
+    if (messages.length === 0) return;
+    const [baseName] = mindName.split("@", 2);
+    const config = getRoutingConfig(baseName);
+    const sessionConfig = resolveDeliveryMode(config, session);
+    dlog2.info(
+      `flushing batch for ${mindName}/${session}: ${messages.length} messages${interruptOverride ? " (new-speaker interrupt)" : ""}`
+    );
+    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);
+    await this.persistToQueue(baseName, session, payload, "gated");
+    try {
+      const db = await getDb();
+      const count = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
+        and(
+          eq(deliveryQueue.mind, baseName),
+          eq(deliveryQueue.channel, payload.channel),
+          eq(deliveryQueue.status, "gated")
+        )
+      );
+      if ((count[0]?.count ?? 0) <= 1) {
+        await this.sendInviteNotification(mindName, payload);
+      }
+    } catch (err) {
+      dlog2.warn(`failed to check gated count for ${baseName}`, logger_default.errorData(err));
+    }
+  }
+  async sendInviteNotification(mindName, payload) {
+    const text = extractTextContent(payload.content);
+    const preview = text.length > 200 ? `${text.slice(0, 200)}...` : text;
+    const channel = payload.channel ?? "unknown";
+    const notification = [
+      `[New channel: ${channel}]`,
+      `Sender: ${payload.sender ?? "unknown"}`,
+      payload.platform ? `Platform: ${payload.platform}` : null,
+      payload.participantCount ? `Participants: ${payload.participantCount}` : null,
+      "",
+      `Preview: ${preview}`,
+      "",
+      `To accept this channel, add a routing rule for "${channel}" to your routes.json.`,
+      `Messages are being held until a route is configured.`
+    ].filter((line) => line !== null).join("\n");
+    const invitePayload = {
+      channel: "system:delivery",
+      sender: "system",
+      content: [{ type: "text", text: notification }]
+    };
+    const config = getRoutingConfig(mindName.split("@", 2)[0]);
+    const sessionConfig = resolveDeliveryMode(config, "main");
+    await this.deliverToMind(mindName, "main", invitePayload, {
+      ...sessionConfig,
+      interrupt: true
+    });
+  }
+  async persistToQueue(mindName, session, payload, status = "pending") {
+    try {
+      const db = await getDb();
+      await db.insert(deliveryQueue).values({
+        mind: mindName,
+        session,
+        channel: payload.channel ?? null,
+        sender: payload.sender ?? null,
+        status,
+        payload: JSON.stringify(payload)
+      });
+    } catch (err) {
+      dlog2.warn(
+        `failed to persist to delivery queue for ${mindName}/${session}`,
+        logger_default.errorData(err)
+      );
+    }
+  }
+  incrementActive(mind, session, senders, channels) {
+    let mindSessions = this.sessionStates.get(mind);
+    if (!mindSessions) {
+      mindSessions = /* @__PURE__ */ new Map();
+      this.sessionStates.set(mind, mindSessions);
+    }
+    const state = mindSessions.get(session) ?? {
+      activeCount: 0,
+      lastDeliveredAt: 0,
+      lastDeliverySenders: /* @__PURE__ */ new Set(),
+      lastDeliveryChannels: /* @__PURE__ */ new Set(),
+      lastInterruptAt: 0
+    };
+    state.activeCount++;
+    state.lastDeliveredAt = Date.now();
+    if (senders) state.lastDeliverySenders = senders;
+    if (channels) state.lastDeliveryChannels = channels;
+    mindSessions.set(session, state);
+  }
+  decrementActive(mind, session) {
+    const mindSessions = this.sessionStates.get(mind);
+    if (!mindSessions) return;
+    const state = mindSessions.get(session);
+    if (!state) return;
+    state.activeCount = Math.max(0, state.activeCount - 1);
+    if (state.activeCount === 0) {
+      const bufferKey = `${mind}:${session}`;
+      const buffer = this.batchBuffers.get(bufferKey);
+      if (buffer && buffer.messages.length > 0) {
+        this.scheduleBatchTimers(mind, session, bufferKey);
+      }
+    }
+  }
+};
+var instance3;
+function initDeliveryManager() {
+  if (instance3) throw new Error("DeliveryManager already initialized");
+  instance3 = new DeliveryManager();
+  return instance3;
+}
+function getDeliveryManager() {
+  if (!instance3) {
+    throw new Error("DeliveryManager not initialized \u2014 call initDeliveryManager() first");
+  }
+  return instance3;
+}
+
+// src/lib/delivery/message-delivery.ts
+var dlog3 = logger_default.child("delivery");
+async function deliverMessage(mindName, payload) {
+  try {
+    const [baseName] = mindName.split("@", 2);
+    const entry = findMind(baseName);
+    if (!entry) {
+      dlog3.warn(`cannot deliver to ${mindName}: mind not found`);
+      return;
+    }
+    const textContent = extractTextContent(payload.content);
+    try {
+      const db = await getDb();
+      await db.insert(mindHistory).values({
+        mind: baseName,
+        type: "inbound",
+        channel: payload.channel,
+        sender: payload.sender ?? null,
+        content: textContent
+      });
+    } catch (err) {
+      dlog3.warn(`failed to persist message for ${baseName}`, logger_default.errorData(err));
+    }
+    const sleepManager = getSleepManagerIfReady();
+    if (sleepManager?.isSleeping(baseName)) {
+      if (sleepManager.checkWakeTrigger(baseName, payload)) {
+        await sleepManager.queueSleepMessage(baseName, payload);
+        sleepManager.initiateWake(baseName, { trigger: { channel: payload.channel } }).catch((err) => dlog3.warn(`failed to trigger-wake ${baseName}`, logger_default.errorData(err)));
+      } else {
+        await sleepManager.queueSleepMessage(baseName, payload);
+      }
+      return;
+    }
+    const manager = getDeliveryManager();
+    await manager.routeAndDeliver(mindName, payload);
+  } catch (err) {
+    dlog3.warn(`unexpected error delivering to ${mindName}`, logger_default.errorData(err));
+  }
+}
+
+// src/lib/daemon/mail-poller.ts
+var mlog = logger_default.child("mail");
+function formatEmailContent(email) {
+  if (email.body) {
+    return email.subject ? `Subject: ${email.subject}
+
+${email.body}` : email.body;
+  }
+  if (email.html) {
+    return email.subject ? `Subject: ${email.subject}
+
+[HTML email \u2014 plain text not available]` : "[HTML email \u2014 plain text not available]";
+  }
+  return email.subject ? `Subject: ${email.subject}` : "[Empty email]";
+}
+var PING_INTERVAL_MS = 3e4;
+var INITIAL_RECONNECT_MS = 1e3;
+var MAX_RECONNECT_MS = 6e4;
+var MailPoller = class {
+  ws = null;
+  running = false;
+  pingTimer = null;
+  reconnectTimer = null;
+  reconnectDelay = INITIAL_RECONNECT_MS;
+  reconnectAttempts = 0;
+  disconnectedAt = null;
+  config = null;
+  start() {
+    if (this.running) {
+      mlog.warn("already running \u2014 ignoring duplicate start");
+      return;
+    }
+    this.config = readSystemsConfig();
+    if (!this.config) {
+      mlog.info("no systems config \u2014 mail disabled");
+      return;
+    }
+    this.running = true;
+    this.connect();
+  }
+  stop() {
+    this.running = false;
+    this.config = null;
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    this.pingTimer = null;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  isRunning() {
+    return this.running;
+  }
+  connect() {
+    if (!this.running) return;
+    this.config = readSystemsConfig();
+    if (!this.config) {
+      mlog.info("systems config removed \u2014 stopping");
+      this.stop();
+      return;
+    }
+    const wsUrl = `${this.config.apiUrl.replace(/^http/, "ws")}/api/ws`;
+    try {
+      this.ws = new WebSocket(wsUrl, {
+        headers: { Authorization: `Bearer ${this.config.apiKey}` }
+      });
+    } catch (err) {
+      mlog.warn("failed to create WebSocket", logger_default.errorData(err));
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws.onopen = () => {
+      if (this.reconnectAttempts > 0) {
+        mlog.info(`reconnected after ${this.reconnectAttempts} attempts`);
+      }
+      mlog.info("connected");
+      this.reconnectAttempts = 0;
+      this.reconnectDelay = INITIAL_RECONNECT_MS;
+      if (this.disconnectedAt) {
+        this.catchUp(this.disconnectedAt);
+        this.disconnectedAt = null;
+      }
+      if (this.pingTimer) clearInterval(this.pingTimer);
+      this.pingTimer = setInterval(() => {
+        try {
+          if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send("ping");
+          }
+        } catch (err) {
+          mlog.warn("ping failed", logger_default.errorData(err));
+        }
+      }, PING_INTERVAL_MS);
+    };
+    this.ws.onmessage = (event) => {
+      this.handleMessage(String(event.data));
+    };
+    this.ws.onclose = () => {
+      mlog.warn("disconnected");
+      if (!this.disconnectedAt) {
+        this.disconnectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      this.cleanup();
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = (err) => {
+      mlog.warn("WebSocket error", logger_default.errorData(err));
+    };
+  }
+  cleanup() {
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    this.pingTimer = null;
+    this.ws = null;
+  }
+  scheduleReconnect() {
+    if (!this.running) return;
+    this.reconnectAttempts++;
+    if (this.reconnectAttempts % 10 === 0) {
+      mlog.warn(
+        `failed to connect ${this.reconnectAttempts} times \u2014 check systems config and network`
+      );
+    }
+    mlog.info(`reconnecting in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.reconnectDelay);
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_MS);
+  }
+  /** Fetch emails that arrived while disconnected */
+  catchUp(since) {
+    if (!this.config) return;
+    const url = `${this.config.apiUrl}/api/mail/system/poll?since=${encodeURIComponent(since)}`;
+    fetch(url, {
+      headers: { Authorization: `Bearer ${this.config.apiKey}` }
+    }).then(async (res) => {
+      if (!res.ok) {
+        mlog.warn(`catch-up poll failed: HTTP ${res.status}`);
+        return;
+      }
+      const data = await res.json();
+      if (!Array.isArray(data.emails) || data.emails.length === 0) return;
+      mlog.info(`catching up on ${data.emails.length} missed emails`);
+      for (const email of data.emails) {
+        await this.deliver(email.mind, email);
+      }
+    }).catch((err) => {
+      mlog.warn("catch-up error", logger_default.errorData(err));
+    });
+  }
+  handleMessage(data) {
+    if (data === "pong") return;
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      mlog.warn(`received unparseable message: ${data.slice(0, 200)}`);
+      return;
+    }
+    if (msg.type !== "email") return;
+    if (!msg.mind || !msg.email?.id) {
+      mlog.warn(`received malformed email notification: ${data.slice(0, 500)}`);
+      return;
+    }
+    this.fetchAndDeliver(msg.mind, msg.email).catch((err) => {
+      mlog.warn(`failed to process email for ${msg.mind}`, logger_default.errorData(err));
+    });
+  }
+  async fetchAndDeliver(mind, notification) {
+    if (!this.config) {
+      mlog.warn(`systems config missing \u2014 cannot fetch email ${notification.id} for ${mind}`);
+      return;
+    }
+    const url = `${this.config.apiUrl}/api/mail/emails/${encodeURIComponent(mind)}/${encodeURIComponent(notification.id)}`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.config.apiKey}` }
+    });
+    if (!res.ok) {
+      mlog.warn(`failed to fetch email ${notification.id}: HTTP ${res.status}`);
+      return;
+    }
+    const email = await res.json();
+    await this.deliver(mind, { ...email, mind });
+  }
+  async deliver(mind, email) {
+    const entry = findMind(mind);
+    if (!entry || !entry.running) {
+      mlog.warn(`skipping delivery to ${mind}: ${!entry ? "not found" : "not running"}`);
+      return;
+    }
+    const text = formatEmailContent(email);
+    try {
+      await deliverMessage(mind, {
+        content: [{ type: "text", text }],
+        channel: `mail:${email.from.address}`,
+        sender: email.from.name || email.from.address,
+        platform: "Email",
+        isDM: true
+      });
+      mlog.info(`delivered email from ${email.from.address} to ${mind}`);
+    } catch (err) {
+      mlog.warn(`failed to deliver to ${mind}`, logger_default.errorData(err));
+    }
+  }
+};
+var instance4 = 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;
+}
+async function ensureMailAddress(mindName) {
+  const config = readSystemsConfig();
+  if (!config) return;
+  try {
+    const res = await fetch(`${config.apiUrl}/api/mail/addresses/${encodeURIComponent(mindName)}`, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!res.ok) {
+      mlog.warn(`failed to ensure address for ${mindName}: HTTP ${res.status}`);
+    }
+    await res.text().catch(() => {
+    });
+  } catch (err) {
+    mlog.warn(`failed to ensure address for ${mindName}`, logger_default.errorData(err));
+  }
+}
+
+// src/lib/daemon/scheduler.ts
+import { resolve as resolve5 } from "path";
+import { CronExpressionParser } from "cron-parser";
+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 resolve5(voluteHome(), "scheduler-state.json");
+  }
+  start() {
+    this.loadState();
+    this.interval = setInterval(() => this.tick(), 6e4);
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+  }
+  loadState() {
+    this.lastFired = loadJsonMap(this.statePath);
+  }
+  saveState() {
+    saveJsonMap(this.statePath, this.lastFired);
+  }
+  clearState() {
+    clearJsonMap(this.statePath, this.lastFired);
+  }
+  loadSchedules(mindName) {
+    const dir = mindDir(mindName);
+    const config = readVoluteConfig(dir);
+    if (!config) return;
+    const schedules = config.schedules ?? [];
+    if (schedules.length > 0) {
+      this.schedules.set(mindName, schedules);
+    } else {
+      this.schedules.delete(mindName);
+    }
+  }
+  unloadSchedules(mindName) {
+    this.schedules.delete(mindName);
+  }
+  tick() {
+    const now = /* @__PURE__ */ new Date();
+    const epochMinute = Math.floor(now.getTime() / 6e4);
+    const cronCache = /* @__PURE__ */ new Map();
+    let anyFired = false;
+    for (const [mind, schedules] of this.schedules) {
+      for (const schedule of schedules) {
+        if (!schedule.enabled) continue;
+        if (this.shouldFire(schedule, epochMinute, mind, cronCache)) {
+          anyFired = true;
+          this.fire(mind, schedule);
+        }
+      }
+    }
+    if (anyFired) this.saveState();
+  }
+  shouldFire(schedule, epochMinute, mind, cronCache) {
+    const key = `${mind}:${schedule.id}`;
+    if (this.lastFired.get(key) === epochMinute) return false;
+    let prevMinute = cronCache.get(schedule.cron);
+    if (prevMinute === void 0) {
+      try {
+        const interval = CronExpressionParser.parse(schedule.cron);
+        const prev = interval.prev().toDate();
+        prevMinute = Math.floor(prev.getTime() / 6e4);
+        cronCache.set(schedule.cron, prevMinute);
+      } catch (err) {
+        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        return false;
+      }
+    }
+    if (prevMinute === epochMinute) {
+      this.lastFired.set(key, epochMinute);
+      return true;
+    }
+    return false;
+  }
+  async fire(mindName, schedule) {
+    try {
+      let text;
+      if (schedule.script) {
+        const homeDir = resolve5(mindDir(mindName), "home");
+        try {
+          const output = await this.runScript(schedule.script, homeDir, mindName);
+          if (!output.trim()) {
+            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            return;
+          }
+          text = output;
+        } catch (err) {
+          const stderr = err.stderr ?? "";
+          text = `[script error] ${err.message}${stderr ? `
+${stderr}` : ""}`;
+          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+        }
+      } else if (schedule.message) {
+        text = schedule.message;
+      } else {
+        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
+        return;
+      }
+      await this.deliver(mindName, {
+        content: [{ type: "text", text }],
+        channel: "system:scheduler",
+        sender: schedule.id
+      });
+      slog.info(`fired "${schedule.id}" for ${mindName}`);
+    } catch (err) {
+      slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+  runScript(script, cwd, mindName) {
+    return exec("bash", ["-c", script], { cwd, mindName });
+  }
+  deliver(mindName, payload) {
+    return deliverMessage(mindName, payload);
+  }
+};
+var instance5 = null;
+function initScheduler() {
+  if (instance5) throw new Error("Scheduler already initialized");
+  instance5 = new Scheduler();
+  return instance5;
+}
+function getScheduler() {
+  if (!instance5) throw new Error("Scheduler not initialized \u2014 call initScheduler() first");
+  return instance5;
+}
+
+// src/lib/daemon/token-budget.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+var tlog = logger_default.child("token-budget");
+var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
+var MAX_QUEUE_SIZE = 100;
+var TokenBudget = class {
+  budgets = /* @__PURE__ */ new Map();
+  interval = null;
+  dirty = /* @__PURE__ */ new Set();
+  start() {
+    this.interval = setInterval(() => this.tick(), 6e4);
+  }
+  stop() {
+    this.flush();
+    if (this.interval) clearInterval(this.interval);
+    this.interval = null;
+  }
+  setBudget(mind, tokenLimit, periodMinutes) {
+    if (tokenLimit <= 0) return;
+    const existing = this.budgets.get(mind);
+    if (existing) {
+      existing.tokenLimit = tokenLimit;
+      existing.periodMinutes = periodMinutes;
+    } else {
+      const persisted = this.loadBudgetState(mind);
+      if (persisted) {
+        persisted.tokenLimit = tokenLimit;
+        persisted.periodMinutes = periodMinutes;
+        this.budgets.set(mind, persisted);
+      } else {
+        this.budgets.set(mind, {
+          tokensUsed: 0,
+          periodStart: Date.now(),
+          periodMinutes,
+          tokenLimit,
+          queue: [],
+          warningInjected: false
+        });
+      }
+    }
+  }
+  removeBudget(mind) {
+    this.budgets.delete(mind);
+  }
+  recordUsage(mind, inputTokens, outputTokens) {
+    const state = this.budgets.get(mind);
+    if (!state) return;
+    state.tokensUsed += inputTokens + outputTokens;
+    this.dirty.add(mind);
+  }
+  /** Returns current budget status. Does not mutate state — call acknowledgeWarning() after delivering a warning. */
+  checkBudget(mind) {
+    const state = this.budgets.get(mind);
+    if (!state) return "ok";
+    const pct = state.tokensUsed / state.tokenLimit;
+    if (pct >= 1) return "exceeded";
+    if (pct >= 0.8 && !state.warningInjected) return "warning";
+    return "ok";
+  }
+  /** Mark warning as delivered for this period. Call after successfully injecting the warning. */
+  acknowledgeWarning(mind) {
+    const state = this.budgets.get(mind);
+    if (state) state.warningInjected = true;
+  }
+  enqueue(mind, message) {
+    const state = this.budgets.get(mind);
+    if (!state) return;
+    if (state.queue.length >= MAX_QUEUE_SIZE) {
+      state.queue.shift();
+    }
+    state.queue.push(message);
+  }
+  drain(mind) {
+    const state = this.budgets.get(mind);
+    if (!state) return [];
+    const messages = state.queue;
+    state.queue = [];
+    return messages;
+  }
+  getUsage(mind) {
+    const state = this.budgets.get(mind);
+    if (!state) return null;
+    return {
+      tokensUsed: state.tokensUsed,
+      tokenLimit: state.tokenLimit,
+      periodMinutes: state.periodMinutes,
+      periodStart: state.periodStart,
+      queueLength: state.queue.length,
+      percentUsed: Math.round(state.tokensUsed / state.tokenLimit * 100)
+    };
+  }
+  tick() {
+    const now = Date.now();
+    for (const [mind, state] of this.budgets) {
+      const elapsed = now - state.periodStart;
+      if (elapsed >= state.periodMinutes * 6e4) {
+        state.tokensUsed = 0;
+        state.periodStart = now;
+        state.warningInjected = false;
+        this.dirty.add(mind);
+        const queued = this.drain(mind);
+        if (queued.length > 0) {
+          this.replay(mind, queued).catch((err) => {
+            tlog.warn(`replay error for ${mind}`, logger_default.errorData(err));
+          });
+        }
+      }
+    }
+    this.flush();
+  }
+  /** Flush all dirty budget states to disk. */
+  flush() {
+    for (const mind of this.dirty) {
+      const state = this.budgets.get(mind);
+      if (state) this.saveBudgetState(mind, state);
+    }
+    this.dirty.clear();
+  }
+  budgetStatePath(mind) {
+    return resolve6(stateDir(mind), "budget.json");
+  }
+  saveBudgetState(mind, state) {
+    try {
+      const dir = stateDir(mind);
+      mkdirSync2(dir, { recursive: true });
+      const data = {
+        periodStart: state.periodStart,
+        tokensUsed: state.tokensUsed,
+        warningInjected: state.warningInjected,
+        queue: state.queue
+      };
+      writeFileSync2(this.budgetStatePath(mind), `${JSON.stringify(data)}
+`);
+    } catch (err) {
+      tlog.warn(`failed to save budget state for ${mind}`, logger_default.errorData(err));
+    }
+  }
+  loadBudgetState(mind) {
+    try {
+      const path = this.budgetStatePath(mind);
+      if (!existsSync4(path)) return null;
+      const data = JSON.parse(readFileSync4(path, "utf-8"));
+      if (typeof data.periodStart !== "number" || typeof data.tokensUsed !== "number") return null;
+      return {
+        periodStart: data.periodStart,
+        tokensUsed: data.tokensUsed,
+        warningInjected: data.warningInjected ?? false,
+        queue: Array.isArray(data.queue) ? data.queue : [],
+        periodMinutes: 0,
+        // will be overwritten by caller
+        tokenLimit: 0
+        // will be overwritten by caller
+      };
+    } catch (err) {
+      tlog.warn(`failed to load budget state for ${mind}`, logger_default.errorData(err));
+      return null;
+    }
+  }
+  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}`;
+    }).join("\n");
+    try {
+      await deliverMessage(mindName, {
+        content: [
+          {
+            type: "text",
+            text: `[Budget replay] ${messages.length} queued message(s) from the previous budget period:
+
+${summary}`
+          }
+        ],
+        channel: "system:budget-replay",
+        sender: "system"
+      });
+      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(...messages);
+    }
+  }
+};
+var instance6 = null;
+function initTokenBudget() {
+  if (instance6) throw new Error("TokenBudget already initialized");
+  instance6 = new TokenBudget();
+  return instance6;
+}
+function getTokenBudget() {
+  if (!instance6) throw new Error("TokenBudget not initialized \u2014 call initTokenBudget() first");
+  return instance6;
+}
+
+// src/lib/daemon/mind-service.ts
+async function startMindFull(name) {
+  const [baseName, variantName] = name.split("@", 2);
+  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 || 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))
+  );
+  const config = readVoluteConfig(dir);
+  if (config?.tokenBudget) {
+    getTokenBudget().setBudget(
+      baseName,
+      config.tokenBudget,
+      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+    );
+  }
+  startWatcher(baseName);
+}
+async function sleepMind(name) {
+  markIdle(name);
+  await getMindManager().stopMind(name);
+  publish({
+    type: "mind_sleeping",
+    mind: name,
+    summary: `${name} is sleeping`
+  }).catch((err) => logger_default.error("failed to publish mind_sleeping activity", logger_default.errorData(err)));
+}
+async function wakeMind(name) {
+  await getMindManager().startMind(name);
+  publish({
+    type: "mind_waking",
+    mind: name,
+    summary: `${name} is waking`
+  }).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) {
+    stopWatcher(baseName);
+    markIdle(baseName);
+    await getConnectorManager().stopConnectors(baseName);
+    getScheduler().unloadSchedules(baseName);
+    getTokenBudget().removeBudget(baseName);
+  }
+  await getMindManager().stopMind(name);
+  publish({
+    type: "mind_stopped",
+    mind: name,
+    summary: `${name} stopped`
+  }).catch((err) => logger_default.error("failed to publish mind_stopped activity", logger_default.errorData(err)));
+}
+
+// src/lib/daemon/sleep-manager.ts
+var slog2 = logger_default.child("sleep");
+function defaultState() {
+  return {
+    sleeping: false,
+    sleepingSince: null,
+    scheduledWakeAt: null,
+    wokenByTrigger: false,
+    voluntaryWakeAt: null,
+    queuedMessageCount: 0
+  };
+}
+function formatCurrentDate() {
+  return (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function formatDuration(from, to) {
+  const ms = to.getTime() - from.getTime();
+  const hours = Math.floor(ms / 36e5);
+  const minutes = Math.floor(ms % 36e5 / 6e4);
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+function matchesGlob(pattern, value) {
+  const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+  return re.test(value);
+}
+var SleepManager = class {
+  states = /* @__PURE__ */ new Map();
+  interval = null;
+  unsubActivity = null;
+  transitioning = /* @__PURE__ */ new Set();
+  get statePath() {
+    return resolve7(voluteHome(), "sleep-state.json");
+  }
+  start() {
+    this.loadState();
+    this.interval = setInterval(() => this.tick(), 6e4);
+    this.unsubActivity = subscribe((event) => this.onActivityEvent(event));
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+    this.interval = null;
+    if (this.unsubActivity) this.unsubActivity();
+    this.unsubActivity = null;
+  }
+  // --- State persistence ---
+  loadState() {
+    try {
+      if (existsSync5(this.statePath)) {
+        const data = JSON.parse(readFileSync5(this.statePath, "utf-8"));
+        for (const [name, state] of Object.entries(data)) {
+          this.states.set(name, state);
+        }
+      }
+    } catch (err) {
+      slog2.warn("failed to load sleep state", logger_default.errorData(err));
+    }
+  }
+  saveState() {
+    const data = {};
+    for (const [name, state] of this.states) {
+      if (state.sleeping) data[name] = state;
+    }
+    try {
+      writeFileSync3(this.statePath, `${JSON.stringify(data, null, 2)}
+`);
+    } catch (err) {
+      slog2.error("failed to save sleep state", logger_default.errorData(err));
+    }
+  }
+  // --- Public API ---
+  isSleeping(name) {
+    const state = this.states.get(name);
+    if (!state?.sleeping) return false;
+    if (state.wokenByTrigger) return false;
+    return true;
+  }
+  getState(name) {
+    return this.states.get(name) ?? defaultState();
+  }
+  getSleepConfig(name) {
+    const dir = mindDir(name);
+    const config = readVoluteConfig(dir);
+    return config?.sleep ?? null;
+  }
+  /**
+   * Put a mind to sleep. Sends pre-sleep message, waits for completion,
+   * archives session, then stops the mind process.
+   */
+  async initiateSleep(name, opts) {
+    if (this.isSleeping(name)) return;
+    if (this.transitioning.has(name)) return;
+    this.transitioning.add(name);
+    try {
+      const manager = getMindManager();
+      if (!manager.isRunning(name)) {
+        this.markSleeping(name, opts);
+        return;
+      }
+      const entry = findMind(name);
+      if (!entry) return;
+      const sleepConfig = this.getSleepConfig(name);
+      const wakeTime = opts?.voluntaryWakeAt ?? this.getNextWakeTime(sleepConfig) ?? "scheduled time";
+      const queuedInfo = "";
+      const preSleepMsg = await getPrompt("pre_sleep", { wakeTime, queuedInfo });
+      try {
+        const db = await getDb();
+        await db.insert(mindHistory).values({
+          mind: name,
+          type: "inbound",
+          channel: "system:sleep",
+          content: preSleepMsg
+        });
+      } catch (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`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            content: [{ type: "text", text: preSleepMsg }],
+            channel: "system:sleep"
+          })
+        });
+      } catch (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));
+      await sleepMind(name);
+      await this.killOrphanOnPort(entry.port);
+      await this.archiveSessions(name);
+      this.markSleeping(name, opts);
+      slog2.info(`${name} is now sleeping`);
+    } finally {
+      this.transitioning.delete(name);
+    }
+  }
+  /**
+   * Wake a sleeping mind. Starts the process, delivers wake summary.
+   */
+  async initiateWake(name, opts) {
+    const state = this.states.get(name);
+    if (!state?.sleeping) return;
+    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) {
+        slog2.error(`failed to wake ${name}`, logger_default.errorData(err));
+        return;
+      }
+      const entry = 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
+        });
+      } else {
+        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
+        });
+      } 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) {
+        slog2.info(`flushed ${flushed} queued message(s) for ${name}`);
+      }
+      if (!opts?.trigger) {
+        this.markAwake(name);
+      }
+      slog2.info(`${name} is now awake${opts?.trigger ? " (trigger wake)" : ""}`);
+    } finally {
+      this.transitioning.delete(name);
+    }
+  }
+  /**
+   * Check if a message payload should trigger a wake.
+   */
+  checkWakeTrigger(name, payload) {
+    const config = this.getSleepConfig(name);
+    const triggers = config?.wakeTriggers;
+    const mentionsEnabled = triggers?.mentions !== false;
+    const dmsEnabled = triggers?.dms !== false;
+    if (dmsEnabled && payload.isDM) return true;
+    if (mentionsEnabled && payload.content) {
+      const text = typeof payload.content === "string" ? payload.content : Array.isArray(payload.content) ? payload.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(" ") : "";
+      if (text.includes(`@${name}`)) return true;
+    }
+    if (triggers?.channels) {
+      for (const pattern of triggers.channels) {
+        if (matchesGlob(pattern, payload.channel)) return true;
+      }
+    }
+    if (triggers?.senders && payload.sender) {
+      for (const pattern of triggers.senders) {
+        if (matchesGlob(pattern, payload.sender)) return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Queue a message for a sleeping mind in the delivery_queue table.
+   */
+  async queueSleepMessage(name, payload) {
+    const db = await getDb();
+    await db.insert(deliveryQueue).values({
+      mind: name,
+      session: "sleep",
+      channel: payload.channel,
+      sender: payload.sender ?? null,
+      status: "sleep-queued",
+      payload: JSON.stringify(payload)
+    });
+    const state = this.states.get(name);
+    if (state) {
+      state.queuedMessageCount++;
+      this.saveState();
+    }
+  }
+  /**
+   * Flush all queued sleep messages for a mind through the delivery manager.
+   */
+  async flushQueuedMessages(name) {
+    try {
+      const db = await getDb();
+      const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
+      if (rows.length === 0) return 0;
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-WUS4K4ZC.js");
+      const delivered = [];
+      for (const row of rows) {
+        try {
+          await deliverMessage2(name, JSON.parse(row.payload));
+          delivered.push(row.id);
+        } catch (err) {
+          slog2.warn(`failed to flush queued message ${row.id} for ${name}`, logger_default.errorData(err));
+        }
+      }
+      if (delivered.length > 0) {
+        await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, delivered));
+      }
+      const state = this.states.get(name);
+      if (state) {
+        state.queuedMessageCount = Math.max(0, state.queuedMessageCount - delivered.length);
+      }
+      return delivered.length;
+    } catch (err) {
+      slog2.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
+      return 0;
+    }
+  }
+  // --- Internal methods ---
+  markSleeping(name, opts) {
+    const sleepConfig = this.getSleepConfig(name);
+    const state = {
+      sleeping: true,
+      sleepingSince: (/* @__PURE__ */ new Date()).toISOString(),
+      scheduledWakeAt: this.getNextWakeTime(sleepConfig),
+      wokenByTrigger: false,
+      voluntaryWakeAt: opts?.voluntaryWakeAt ?? null,
+      queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0
+    };
+    this.states.set(name, state);
+    this.saveState();
+  }
+  markAwake(name) {
+    this.states.delete(name);
+    this.saveState();
+  }
+  getNextWakeTime(config) {
+    if (!config?.schedule?.wake) return null;
+    try {
+      const interval = CronExpressionParser2.parse(config.schedule.wake);
+      return interval.next().toDate().toISOString();
+    } catch (err) {
+      slog2.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
+      return null;
+    }
+  }
+  tick() {
+    const now = /* @__PURE__ */ new Date();
+    const epochMinute = Math.floor(now.getTime() / 6e4);
+    const registry = readRegistry();
+    for (const entry of registry) {
+      if (!entry.running && !this.isSleeping(entry.name)) continue;
+      const config = this.getSleepConfig(entry.name);
+      if (!config?.enabled || !config.schedule) continue;
+      const state = this.states.get(entry.name);
+      if (state?.sleeping && state.voluntaryWakeAt) {
+        const wakeAt = new Date(state.voluntaryWakeAt);
+        if (now >= wakeAt) {
+          this.initiateWake(entry.name).catch(
+            (err) => slog2.error(`failed voluntary wake for ${entry.name}`, logger_default.errorData(err))
+          );
+          continue;
+        }
+      }
+      if (state?.sleeping && state.scheduledWakeAt) {
+        const wakeAt = new Date(state.scheduledWakeAt);
+        if (now >= wakeAt) {
+          this.initiateWake(entry.name).catch(
+            (err) => slog2.error(`failed scheduled wake for ${entry.name}`, logger_default.errorData(err))
+          );
+          continue;
+        }
+      }
+      if (!state?.sleeping && entry.running) {
+        if (this.shouldSleep(config.schedule.sleep, epochMinute)) {
+          this.initiateSleep(entry.name).catch(
+            (err) => slog2.error(`failed to initiate sleep for ${entry.name}`, logger_default.errorData(err))
+          );
+        }
+      }
+    }
+  }
+  shouldSleep(cronExpr, epochMinute) {
+    try {
+      const interval = CronExpressionParser2.parse(cronExpr);
+      const prev = interval.prev().toDate();
+      const prevMinute = Math.floor(prev.getTime() / 6e4);
+      return prevMinute === epochMinute;
+    } catch (err) {
+      slog2.warn(`invalid sleep cron "${cronExpr}"`, logger_default.errorData(err));
+      return false;
+    }
+  }
+  async waitForIdle(name, timeoutMs) {
+    return new Promise((resolve8) => {
+      const timeout = setTimeout(() => {
+        unsub();
+        resolve8();
+      }, timeoutMs);
+      const unsub = subscribe((event) => {
+        if (event.mind !== name) return;
+        if (event.type === "mind_done" || event.type === "mind_idle") {
+          clearTimeout(timeout);
+          unsub();
+          resolve8();
+        }
+      });
+    });
+  }
+  async archiveSessions(name) {
+    const dir = mindDir(name);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
+    const sessionsDir = resolve7(dir, ".mind", "sessions");
+    if (existsSync5(sessionsDir)) {
+      const archiveDir = resolve7(sessionsDir, "archive");
+      mkdirSync3(archiveDir, { recursive: true });
+      for (const file of readdirSync2(sessionsDir)) {
+        if (file === "archive" || !file.endsWith(".json")) continue;
+        const src = resolve7(sessionsDir, file);
+        const base = file.replace(/\.json$/, "");
+        const dest = resolve7(archiveDir, `${base}-${timestamp}.json`);
+        try {
+          renameSync(src, dest);
+        } catch (err) {
+          slog2.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
+        }
+      }
+    }
+    const piSessionsDir = resolve7(dir, ".mind", "pi-sessions");
+    if (existsSync5(piSessionsDir)) {
+      const archiveDir = resolve7(piSessionsDir, "archive");
+      mkdirSync3(archiveDir, { recursive: true });
+      for (const entry of readdirSync2(piSessionsDir, { withFileTypes: true })) {
+        if (entry.name === "archive" || !entry.isDirectory()) continue;
+        const src = resolve7(piSessionsDir, entry.name);
+        const dest = resolve7(archiveDir, `${entry.name}-${timestamp}`);
+        try {
+          renameSync(src, dest);
+        } catch (err) {
+          slog2.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
+        }
+      }
+    }
+  }
+  async buildQueuedSummary(name) {
+    try {
+      const db = await getDb();
+      const rows = await db.select({ channel: deliveryQueue.channel }).from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
+      if (rows.length === 0) return "No messages while you slept.";
+      const channelCounts = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const ch = row.channel ?? "unknown";
+        channelCounts.set(ch, (channelCounts.get(ch) ?? 0) + 1);
+      }
+      const parts = [...channelCounts.entries()].map(([ch, count]) => `${count} on ${ch}`);
+      return `${rows.length} message${rows.length === 1 ? "" : "s"} while you slept (${parts.join(", ")}). Ask if you want them delivered.`;
+    } catch (err) {
+      slog2.warn(`failed to build queued summary for ${name}`, logger_default.errorData(err));
+      return "No messages while you slept.";
+    }
+  }
+  /**
+   * Kill any process still listening on a port after stopMind.
+   * Handles the case where a hook (e.g. identity-reload) restarted the server.
+   */
+  async killOrphanOnPort(port) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/health`);
+      if (!res.ok) return;
+    } catch {
+      return;
+    }
+    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"]);
+      for (const line of stdout.trim().split("\n").filter(Boolean)) {
+        const pid = parseInt(line, 10);
+        if (pid > 0) {
+          try {
+            process.kill(pid, "SIGTERM");
+          } catch (err) {
+            if (err.code !== "ESRCH") {
+              slog2.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
+            }
+          }
+        }
+      }
+    } catch {
+      try {
+        const portHex = port.toString(16).toUpperCase().padStart(4, "0");
+        const tcp6 = readFileSync5("/proc/net/tcp6", "utf-8");
+        for (const line of tcp6.split("\n")) {
+          if (!line.includes(`:${portHex} `)) continue;
+          const fields = line.trim().split(/\s+/);
+          if (fields[3] !== "0A") continue;
+          const inode = parseInt(fields[9], 10);
+          if (!inode) continue;
+          for (const pidDir of readdirSync2("/proc").filter((f) => /^\d+$/.test(f))) {
+            try {
+              const fds = readdirSync2(`/proc/${pidDir}/fd`);
+              for (const fd of fds) {
+                try {
+                  const link = readlinkSync(`/proc/${pidDir}/fd/${fd}`);
+                  if (link.includes(`socket:[${inode}]`)) {
+                    process.kill(parseInt(pidDir, 10), "SIGTERM");
+                  }
+                } catch {
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      } catch (err) {
+        slog2.warn(`failed to kill orphan on port ${port} via /proc`, logger_default.errorData(err));
+      }
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  onActivityEvent(event) {
+    const state = this.states.get(event.mind);
+    if (!state?.sleeping || !state.wokenByTrigger) return;
+    if (this.transitioning.has(event.mind)) return;
+    if (event.type === "mind_idle") {
+      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(() => {
+        state.sleeping = true;
+        state.sleepingSince = (/* @__PURE__ */ new Date()).toISOString();
+        const sleepConfig = this.getSleepConfig(event.mind);
+        state.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
+        this.saveState();
+        slog2.info(`${event.mind} returned to sleep`);
+      }).catch((err) => {
+        slog2.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
+      }).finally(() => {
+        this.transitioning.delete(event.mind);
+      });
+    }
+  }
+};
+var instance7 = null;
+function initSleepManager() {
+  if (instance7) throw new Error("SleepManager already initialized");
+  instance7 = new SleepManager();
+  return instance7;
+}
+function getSleepManager() {
+  if (!instance7) throw new Error("SleepManager not initialized \u2014 call initSleepManager() first");
+  return instance7;
+}
+function getSleepManagerIfReady() {
+  return instance7;
+}
+
+export {
+  initConnectorManager,
+  getConnectorManager,
+  stopAllWatchers,
+  getCachedSites,
+  getCachedRecentPages,
+  initScheduler,
+  getScheduler,
+  initTokenBudget,
+  getTokenBudget,
+  startMindFull,
+  stopMindFull,
+  matchesGlob,
+  SleepManager,
+  initSleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  subscribe2 as subscribe,
+  publish2 as publish,
+  getTypingMap,
+  publishTypingForChannels,
+  extractTextContent,
+  initDeliveryManager,
+  getDeliveryManager,
+  deliverMessage,
+  initMailPoller,
+  getMailPoller
+};