volute 0.48.0 → 0.50.0

package/dist/chunk-EQKSRVDE.js

@@ -0,0 +1,2857 @@
+#!/usr/bin/env node
+import {
+  spiritDir
+} from "./chunk-SFRYRW37.js";
+import {
+  getScheduler
+} from "./chunk-7FDWPQCU.js";
+import {
+  getDeliveryManager
+} from "./chunk-JI67D7O2.js";
+import {
+  getMindManager,
+  resolveMindToken
+} from "./chunk-ALIVXDM4.js";
+import {
+  extractTextContent,
+  getRoutingConfig,
+  resolveRoute,
+  shouldGate
+} from "./chunk-6BM2I736.js";
+import {
+  hashSkillDir,
+  importSkillFromDir,
+  removeSharedSkill,
+  sharedSkillsDir
+} from "./chunk-TGJHGVBZ.js";
+import {
+  getOrCreateMindUser,
+  getOrCreateSystemUser,
+  getUser,
+  getUserByUsername,
+  syncMindProfile
+} from "./chunk-UC6BNMGT.js";
+import {
+  MIND_LEVEL_THREAD,
+  deliverEvent,
+  flushQueuedEvents,
+  pendingEventCount,
+  pendingEventsLine,
+  recordNotice
+} from "./chunk-7OZWKHA3.js";
+import {
+  publish as publish2
+} from "./chunk-LNNI3MS4.js";
+import {
+  getPrompt
+} from "./chunk-5TPC4KCV.js";
+import {
+  addMessage,
+  createChannel,
+  createConversation,
+  findDMConversation,
+  getChannelByName,
+  getChannelSettings,
+  getParticipants,
+  joinChannel,
+  updateChannelSettings
+} from "./chunk-574M6I7F.js";
+import {
+  markIdle
+} from "./chunk-E5S3ILVA.js";
+import {
+  publish,
+  subscribe
+} from "./chunk-3BAFMGCJ.js";
+import {
+  readVoluteConfig,
+  resolveWakeTriggers
+} from "./chunk-WCFSBH33.js";
+import {
+  isIsolationEnabled,
+  mindUserName
+} from "./chunk-AJWFDIEY.js";
+import {
+  missingCredentialWarning
+} from "./chunk-632FJ23O.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  getBaseName,
+  getDb,
+  getSpiritName,
+  getSystemName,
+  mindDir,
+  readGlobalConfig,
+  readRegistry,
+  stateDir,
+  voluteHome,
+  voluteSystemDir,
+  writeGlobalConfig
+} from "./chunk-CAIYV33P.js";
+import {
+  activity,
+  deliveryQueue,
+  messages,
+  mindHistory,
+  sessions
+} from "./chunk-5IIVOWSP.js";
+
+// packages/daemon/src/lib/extensions.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, resolve as resolve5 } from "path";
+
+// packages/daemon/src/web/middleware/auth.ts
+import { timingSafeEqual } from "crypto";
+import { eq, lt } from "drizzle-orm";
+import { getCookie } from "hono/cookie";
+import { createMiddleware } from "hono/factory";
+var MIND_USER_CACHE_TTL = 5 * 60 * 1e3;
+var mindUserCache = /* @__PURE__ */ new Map();
+var alog = logger_default.child("auth");
+var legacySessionHeaderWarned = /* @__PURE__ */ new Set();
+function warnLegacySessionHeader(legacyHeader, mindName) {
+  if (!legacyHeader || legacySessionHeaderWarned.has(mindName)) return;
+  legacySessionHeaderWarned.add(mindName);
+  alog.warn(
+    `mind ${mindName} sent legacy X-Volute-Session header (now X-Volute-Thread); run \`volute mind upgrade ${mindName}\` to update its template`
+  );
+}
+function invalidateMindUserCache(mindName) {
+  mindUserCache.delete(mindName);
+}
+function isValidDaemonToken(token) {
+  const expected = process.env.VOLUTE_DAEMON_TOKEN;
+  if (!expected || token.length !== expected.length) return false;
+  return timingSafeEqual(Buffer.from(token), Buffer.from(expected));
+}
+var SESSION_MAX_AGE = 365 * 24 * 60 * 60 * 1e3;
+var SESSION_CACHE_TTL = 5 * 60 * 1e3;
+var sessionCache = /* @__PURE__ */ new Map();
+function invalidateSessionCache(sessionId) {
+  sessionCache.delete(sessionId);
+}
+async function createSession(userId) {
+  const db = await getDb();
+  const sessionId = crypto.randomUUID();
+  await db.insert(sessions).values({ id: sessionId, userId, createdAt: Date.now() });
+  return sessionId;
+}
+async function deleteSession(sessionId) {
+  sessionCache.delete(sessionId);
+  const db = await getDb();
+  await db.delete(sessions).where(eq(sessions.id, sessionId));
+}
+async function getSessionUserId(sessionId) {
+  const db = await getDb();
+  const row = await db.select().from(sessions).where(eq(sessions.id, sessionId)).get();
+  if (!row) return void 0;
+  if (Date.now() - row.createdAt > SESSION_MAX_AGE) {
+    await db.delete(sessions).where(eq(sessions.id, sessionId));
+    return void 0;
+  }
+  return row.userId;
+}
+async function cleanExpiredSessions() {
+  const now = Date.now();
+  for (const [id, cached] of sessionCache) {
+    if (cached.expires <= now) sessionCache.delete(id);
+  }
+  const db = await getDb();
+  const cutoff = Date.now() - SESSION_MAX_AGE;
+  await db.delete(sessions).where(lt(sessions.createdAt, cutoff));
+}
+var requireAdmin = createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin") {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+  await next();
+});
+var requireAdminOrSystem = createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin" && user.role !== "system") {
+    return c.json({ error: "Forbidden" }, 403);
+  }
+  await next();
+});
+async function resolveSession(sessionId) {
+  const cached = sessionCache.get(sessionId);
+  if (cached && cached.expires > Date.now()) {
+    return cached.user;
+  }
+  const userId = await getSessionUserId(sessionId);
+  if (userId == null) {
+    sessionCache.delete(sessionId);
+    return null;
+  }
+  const user = await getUser(userId);
+  if (!user) {
+    sessionCache.delete(sessionId);
+    return null;
+  }
+  sessionCache.set(sessionId, { userId, user, expires: Date.now() + SESSION_CACHE_TTL });
+  return user;
+}
+var authMiddleware = createMiddleware(async (c, next) => {
+  const authHeader = c.req.header("Authorization");
+  if (authHeader?.startsWith("Bearer ")) {
+    const token = authHeader.slice(7);
+    if (token && isValidDaemonToken(token)) {
+      c.set("user", {
+        id: 0,
+        username: "daemon",
+        role: "admin",
+        user_type: "human",
+        display_name: null,
+        description: null,
+        avatar: null
+      });
+      const mindSessionHeader = c.req.header("X-Volute-Thread");
+      if (mindSessionHeader) c.set("mindSession", mindSessionHeader);
+      await next();
+      return;
+    }
+    const mindName = resolveMindToken(token);
+    if (mindName) {
+      const cached = mindUserCache.get(mindName);
+      let mindUser;
+      if (cached && Date.now() - cached.ts < MIND_USER_CACHE_TTL) {
+        mindUser = cached.user;
+      } else {
+        mindUser = await getOrCreateMindUser(mindName);
+        mindUserCache.set(mindName, { user: mindUser, ts: Date.now() });
+      }
+      c.set("user", mindUser);
+      const mindSessionHeader = c.req.header("X-Volute-Thread");
+      if (mindSessionHeader) c.set("mindSession", mindSessionHeader);
+      else warnLegacySessionHeader(c.req.header("X-Volute-Session"), mindName);
+      await next();
+      return;
+    }
+    if (token) {
+      const user2 = await resolveSession(token);
+      if (user2) {
+        if (user2.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+        c.set("user", user2);
+        await next();
+        return;
+      }
+    }
+  }
+  const sessionId = getCookie(c, "volute_session");
+  if (!sessionId) return c.json({ error: "Unauthorized" }, 401);
+  const user = await resolveSession(sessionId);
+  if (!user) return c.json({ error: "Unauthorized" }, 401);
+  if (user.role === "pending") return c.json({ error: "Account pending approval" }, 403);
+  c.set("user", user);
+  await next();
+});
+var requireSelf = (paramName = "name") => createMiddleware(async (c, next) => {
+  const user = c.get("user");
+  if (user.role !== "admin" && user.role !== "system") {
+    const target = c.req.param(paramName) ?? "";
+    const baseName = await getBaseName(target);
+    if (user.username !== baseName && await getBaseName(user.username) !== baseName) {
+      return c.json({ error: "Forbidden" }, 403);
+    }
+  }
+  await next();
+});
+
+// packages/daemon/src/lib/delivery/message-delivery.ts
+import { and as and2, eq as eq3, inArray as inArray2 } from "drizzle-orm";
+
+// packages/daemon/src/lib/daemon/sleep-manager.ts
+import { execFile, spawn as spawnChild } from "child_process";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync4,
+  readlinkSync,
+  renameSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { resolve as resolve4 } from "path";
+import { promisify } from "util";
+import { CronExpressionParser } from "cron-parser";
+import { and, eq as eq2, inArray } from "drizzle-orm";
+
+// packages/daemon/src/lib/daemon/mind-service.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// packages/daemon/src/lib/chat/system-chat.ts
+var dmCache = /* @__PURE__ */ new Map();
+async function ensureSystemDM(mindName) {
+  const cached = dmCache.get(mindName);
+  if (cached) return { conversationId: cached };
+  const systemUser = await getOrCreateSystemUser();
+  const mindUser = await getOrCreateMindUser(mindName);
+  if (systemUser.id === mindUser.id) {
+    throw new Error(`Cannot create system DM: mind "${mindName}" is the system user`);
+  }
+  const existing = await findDMConversation([systemUser.id, mindUser.id]);
+  if (existing) {
+    dmCache.set(mindName, existing);
+    return { conversationId: existing };
+  }
+  const conv = await createConversation({
+    participantIds: [systemUser.id, mindUser.id]
+  });
+  dmCache.set(mindName, conv.id);
+  return { conversationId: conv.id };
+}
+
+// packages/daemon/src/lib/config/systems-config.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { resolve } from "path";
+var DEFAULT_API_URL = "https://volute.systems";
+function configPath() {
+  return resolve(voluteSystemDir(), "systems.json");
+}
+function readSystemsConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf-8");
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    console.error(
+      `Warning: ${path} contains invalid JSON. Run "volute systems logout" and re-login.`
+    );
+    return null;
+  }
+  if (!data.apiKey || !data.system) return null;
+  return {
+    apiKey: data.apiKey,
+    system: data.system,
+    apiUrl: data.apiUrl || DEFAULT_API_URL
+  };
+}
+function writeSystemsConfig(config) {
+  mkdirSync(voluteSystemDir(), { recursive: true });
+  writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+function deleteSystemsConfig() {
+  try {
+    unlinkSync(configPath());
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+
+// packages/daemon/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) {
+        void this.catchUpAndClear(this.disconnectedAt);
+      }
+      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.info("disconnected");
+      if (!this.disconnectedAt) {
+        this.disconnectedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      this.cleanup();
+      this.scheduleReconnect();
+    };
+    this.ws.onerror = (err) => {
+      mlog.info("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);
+  }
+  /**
+   * Run catch-up and advance the watermark only on full success. On any failure
+   * (fetch error, non-OK response, delivery throw) the watermark is retained so
+   * the next reconnect re-fetches the gap — at-least-once, never dropped.
+   */
+  async catchUpAndClear(since) {
+    try {
+      await this.catchUp(since);
+    } catch (err) {
+      mlog.info("catch-up failed \u2014 will retry on next reconnect", logger_default.errorData(err));
+      return;
+    }
+    if (this.disconnectedAt === since && this.ws?.readyState === WebSocket.OPEN) {
+      this.disconnectedAt = null;
+    }
+  }
+  /** Fetch and deliver emails that arrived while disconnected. Throws on failure. */
+  async catchUp(since) {
+    if (!this.config) throw new Error("systems config missing");
+    const url = `${this.config.apiUrl}/api/mail/system/poll?since=${encodeURIComponent(since)}`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${this.config.apiKey}` }
+    });
+    if (!res.ok) {
+      throw new Error(`catch-up poll failed: HTTP ${res.status}`);
+    }
+    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);
+    }
+  }
+  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) {
+    if (!await findMind(mind)) {
+      mlog.warn(`skipping delivery to ${mind}: mind not found`);
+      return;
+    }
+    const text = formatEmailContent(email);
+    const delivered = await deliverMessage(mind, {
+      content: [{ type: "text", text }],
+      channel: `mail:${email.from.address}`,
+      sender: email.from.name || email.from.address,
+      platform: "Email",
+      isDM: true
+    });
+    if (!delivered) {
+      throw new Error(`delivery to ${mind} failed`);
+    }
+    mlog.info(`delivered email from ${email.from.address} to ${mind}`);
+  }
+};
+var instance = null;
+function initMailPoller() {
+  if (instance) throw new Error("MailPoller already initialized");
+  instance = new MailPoller();
+  return instance;
+}
+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));
+  }
+}
+
+// packages/daemon/src/lib/daemon/token-budget.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { resolve as resolve2 } 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().catch((err) => tlog.error("token budget tick failed", logger_default.errorData(err)));
+    }, 6e4);
+  }
+  async stop() {
+    await 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,
+          exceededNotified: 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;
+  }
+  /**
+   * Returns true exactly once per budget period when the mind first crosses its limit,
+   * so callers can record a single "budget exceeded" notice without repeating it on
+   * every subsequent usage event. The flag resets when the period rolls over.
+   */
+  noteExceeded(mind) {
+    const state = this.budgets.get(mind);
+    if (!state) return false;
+    if (state.tokensUsed < state.tokenLimit) return false;
+    if (state.exceededNotified) return false;
+    state.exceededNotified = true;
+    this.dirty.add(mind);
+    return 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 messages2 = state.queue;
+    state.queue = [];
+    return messages2;
+  }
+  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)
+    };
+  }
+  async 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;
+        state.exceededNotified = 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));
+          });
+        }
+      }
+    }
+    await this.flush();
+  }
+  /** Flush all dirty budget states to disk. */
+  async flush() {
+    const flushing = new Set(this.dirty);
+    this.dirty.clear();
+    const writes = [];
+    for (const mind of flushing) {
+      const state = this.budgets.get(mind);
+      if (state) writes.push(this.saveBudgetState(mind, state).catch(() => this.dirty.add(mind)));
+    }
+    await Promise.all(writes);
+  }
+  budgetStatePath(mind) {
+    return resolve2(stateDir(mind), "budget.json");
+  }
+  async saveBudgetState(mind, state) {
+    try {
+      const dir = stateDir(mind);
+      await mkdir(dir, { recursive: true });
+      const data = {
+        periodStart: state.periodStart,
+        tokensUsed: state.tokensUsed,
+        warningInjected: state.warningInjected,
+        exceededNotified: state.exceededNotified,
+        queue: state.queue
+      };
+      await writeFile(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 (!existsSync2(path)) return null;
+      const data = JSON.parse(readFileSync2(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,
+        exceededNotified: data.exceededNotified ?? 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, messages2) {
+    const summary = messages2.map((m) => {
+      const from = m.sender ? `[${m.sender}]` : "";
+      const ch = m.channel ? `(${m.channel})` : "";
+      return `${from}${ch} ${m.textContent}`;
+    }).join("\n");
+    try {
+      await deliverEvent(mindName, {
+        type: "budget",
+        meta: { subtype: "replay" },
+        body: `${messages2.length} queued message(s) from the previous budget period:
+
+${summary}`
+      });
+      tlog.info(`replayed ${messages2.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);
+    }
+  }
+};
+var instance2 = null;
+function initTokenBudget() {
+  if (instance2) throw new Error("TokenBudget already initialized");
+  instance2 = new TokenBudget();
+  return instance2;
+}
+function getTokenBudget() {
+  if (!instance2) throw new Error("TokenBudget not initialized \u2014 call initTokenBudget() first");
+  return instance2;
+}
+
+// packages/daemon/src/lib/daemon/mind-service.ts
+async function startMindFull(name) {
+  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 (entry?.parent) return;
+  recordMissingCredentialsNotice(baseName, entry?.template).catch(
+    (err) => logger_default.error(`failed to check credentials for ${baseName}`, logger_default.errorData(err))
+  );
+  if (!entry || entry.stage === "seed") {
+    if (entry?.stage === "seed") {
+      sendSeedOrientation(baseName, entry.createdBy).catch(
+        (err) => logger_default.error(`failed to send seed orientation for ${baseName}`, logger_default.errorData(err))
+      );
+      ensureSystemDM(baseName).catch(
+        (err) => logger_default.error(`failed to ensure system DM for ${baseName}`, logger_default.errorData(err))
+      );
+      if (entry.createdBy) {
+        ensureCreatorDM(baseName, entry.createdBy).catch(
+          (err) => logger_default.error(`failed to ensure creator DM for ${baseName}`, logger_default.errorData(err))
+        );
+      }
+    } else {
+      ensureSystemDM(baseName).catch(
+        (err) => logger_default.error(`failed to ensure system DM for ${baseName}`, logger_default.errorData(err))
+      );
+    }
+    return;
+  }
+  ensureSystemDM(baseName).catch(
+    (err) => logger_default.error(`failed to ensure system DM for ${baseName}`, logger_default.errorData(err))
+  );
+  const dir = mindDir(baseName);
+  getScheduler().loadSchedules(baseName);
+  getSleepManagerIfReady()?.loadSleepConfig(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) {
+    syncMindProfile(baseName, config.profile ?? {}).catch(
+      (err) => logger_default.error(`failed to sync profile for ${baseName}`, logger_default.errorData(err))
+    );
+  }
+  joinSystemChannelForMind(baseName).catch(
+    (err) => logger_default.warn(`failed to join #system for ${baseName}`, logger_default.errorData(err))
+  );
+  if (config?.tokenBudget) {
+    getTokenBudget().setBudget(
+      baseName,
+      config.tokenBudget,
+      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+    );
+  }
+  notifyExtensionsMindStart(baseName);
+}
+async function recordMissingCredentialsNotice(mind, template) {
+  const { hasUndeliveredEvent, recordNotice: recordNotice2, MIND_LEVEL_THREAD: MIND_LEVEL_THREAD2 } = await import("./system-events-A6IGCEC3.js");
+  const warning = await missingCredentialWarning(template, readMindModel(mind, template), mind);
+  if (!warning) return;
+  if (await hasUndeliveredEvent(mind, "no_credentials")) return;
+  await recordNotice2({
+    mind,
+    thread: MIND_LEVEL_THREAD2,
+    kind: "startup",
+    reason: "no_credentials",
+    detail: warning
+  });
+}
+function readMindModel(mind, template) {
+  if (template !== "pi") return void 0;
+  try {
+    const configPath2 = resolve3(mindDir(mind), "home/.config/config.json");
+    if (!existsSync3(configPath2)) return void 0;
+    const model = JSON.parse(readFileSync3(configPath2, "utf-8")).model;
+    return typeof model === "string" ? model : void 0;
+  } catch (err) {
+    logger_default.warn(`failed to read model for ${mind}`, logger_default.errorData(err));
+    return void 0;
+  }
+}
+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 startSpiritFull(name) {
+  const entry = await findMind(name);
+  if (entry?.dir) {
+    const { registerMindDir } = await import("./delivery-router-JE7SHYNU.js");
+    registerMindDir(name, entry.dir);
+  }
+  await getMindManager().startMind(name);
+  joinSystemChannelForSpirit().catch(
+    (err) => logger_default.error(`failed to join #system for ${name}`, logger_default.errorData(err))
+  );
+  getScheduler().loadSchedules(name, entry?.dir ?? spiritDir());
+  publish({
+    type: "mind_started",
+    mind: name,
+    summary: `${name} spirit started`
+  }).catch((err) => logger_default.error("failed to publish spirit_started activity", logger_default.errorData(err)));
+}
+async function stopSpiritFull(name) {
+  markIdle(name);
+  getScheduler().unloadSchedules(name);
+  await getMindManager().stopMind(name);
+  publish({
+    type: "mind_stopped",
+    mind: name,
+    summary: `${name} spirit stopped`
+  }).catch((err) => logger_default.error("failed to publish spirit_stopped activity", logger_default.errorData(err)));
+}
+function buildSeedOrientation(createdBy, creatorType) {
+  const intro = `You've just been created as a seed on ${getSystemName()}. Start a conversation \u2014 introduce yourself, ask questions, and begin exploring who you want to be.`;
+  if (!createdBy) return intro;
+  const who = creatorType === "mind" ? `another mind, ${createdBy}` : creatorType === "system" ? `the spirit of this system (${createdBy})` : createdBy;
+  return `${intro} Your creator is ${who}. Send them a message to introduce yourself.`;
+}
+async function sendSeedOrientation(mindName, createdBy) {
+  let creatorType;
+  if (createdBy) {
+    const { getUserByUsername: getUserByUsername2 } = await import("./auth-DT7GY7EZ.js");
+    creatorType = (await getUserByUsername2(createdBy))?.user_type;
+  }
+  await deliverEvent(mindName, {
+    type: "orientation",
+    body: buildSeedOrientation(createdBy, creatorType)
+  });
+}
+async function ensureCreatorDM(mindName, creatorUsername) {
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-DT7GY7EZ.js");
+  const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-S2232Y5I.js");
+  const mindUser = await getOrCreateMindUser2(mindName);
+  const creatorUser = await getUserByUsername2(creatorUsername);
+  if (!creatorUser) {
+    logger_default.warn(`creator user '${creatorUsername}' not found for seed ${mindName} DM`);
+    return;
+  }
+  const existing = await findDMConversation2([mindUser.id, creatorUser.id]);
+  if (!existing) {
+    await createConversation2({
+      participantIds: [mindUser.id, creatorUser.id]
+    });
+  }
+}
+async function stopMindFull(name) {
+  const baseName = await getBaseName(name);
+  const isBase = baseName === name;
+  if (isBase) {
+    notifyExtensionsMindStop(baseName);
+    markIdle(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)));
+}
+
+// packages/daemon/src/lib/daemon/sleep-manager.ts
+var slog = logger_default.child("sleep");
+var MAX_WAKE_ATTEMPTS = 5;
+var WAKE_BACKOFF_MS = [6e4, 5 * 6e4, 15 * 6e4, 60 * 6e4];
+function defaultState() {
+  return {
+    sleeping: false,
+    sleepingSince: null,
+    scheduledWakeAt: null,
+    wokenByTrigger: false,
+    voluntaryWakeAt: null,
+    queuedMessageCount: 0,
+    triggerWakeHistory: [],
+    wakeFailures: 0,
+    nextWakeAttemptAt: null,
+    lastWakeAt: null
+  };
+}
+function formatCurrentDate() {
+  return (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function formatWakeTime(wakeAt) {
+  if (wakeAt) {
+    const date = new Date(wakeAt);
+    if (!Number.isNaN(date.getTime())) {
+      const time = date.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" });
+      const day = date.toLocaleDateString("en-US", {
+        weekday: "long",
+        month: "long",
+        day: "numeric"
+      });
+      return `at ${time} on ${day}`;
+    }
+    return `at ${wakeAt}`;
+  }
+  return "when something needs you \u2014 a message, a mention, or someone waking you";
+}
+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`;
+}
+var globRegexCache = /* @__PURE__ */ new Map();
+function matchesGlob(pattern, value) {
+  let re = globRegexCache.get(pattern);
+  if (!re) {
+    re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+    globRegexCache.set(pattern, re);
+  }
+  return re.test(value);
+}
+var SleepManager = class {
+  states = /* @__PURE__ */ new Map();
+  interval = null;
+  unsubActivity = null;
+  transitioning = /* @__PURE__ */ new Set();
+  sleepConfigs = /* @__PURE__ */ new Map();
+  get statePath() {
+    return resolve4(voluteSystemDir(), "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 (existsSync4(this.statePath)) {
+        const data = JSON.parse(readFileSync4(this.statePath, "utf-8"));
+        for (const [name, state] of Object.entries(data)) {
+          state.triggerWakeHistory ??= [];
+          state.wakeFailures ??= 0;
+          state.nextWakeAttemptAt ??= null;
+          state.lastWakeAt ??= null;
+          this.states.set(name, state);
+        }
+      }
+    } catch (err) {
+      slog.warn("failed to load sleep state", logger_default.errorData(err));
+    }
+  }
+  saveState() {
+    const data = {};
+    for (const [name, state] of this.states) {
+      if (state.sleeping || state.lastWakeAt) data[name] = state;
+    }
+    try {
+      writeFileSync2(this.statePath, `${JSON.stringify(data, null, 2)}
+`);
+    } catch (err) {
+      slog.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();
+  }
+  /**
+   * 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);
+    slog.info(`${name} trigger-wake converted to full wake`);
+  }
+  /**
+   * A trigger-woken mind's process crashed while still in the brief trigger-wake
+   * window. The mind-manager crash handler calls this to return it to sleep —
+   * archive the (now-dead) session and restore sleeping state — rather than
+   * leaving it in sleeping+wokenByTrigger limbo. Mirrors the idle-driven
+   * return-to-sleep in onActivityEvent, minus stopping an already-dead process.
+   */
+  async returnToSleepAfterCrash(name) {
+    const state = this.states.get(name);
+    if (!state?.sleeping || !state.wokenByTrigger) return;
+    if (this.transitioning.has(name)) return;
+    this.transitioning.add(name);
+    state.wokenByTrigger = false;
+    try {
+      try {
+        await sleepMind(name);
+      } catch (err) {
+        slog.warn(`sleepMind during crash-return failed for ${name}`, logger_default.errorData(err));
+      }
+      await this.archiveSessions(name);
+      state.sleeping = true;
+      if (!state.voluntaryWakeAt) {
+        state.scheduledWakeAt = this.getNextWakeTime(this.getSleepConfig(name));
+      }
+      this.saveState();
+      slog.info(`${name} returned to sleep after crashing during trigger wake`);
+    } catch (err) {
+      slog.error(`failed to return ${name} to sleep after crash`, logger_default.errorData(err));
+    } finally {
+      this.transitioning.delete(name);
+    }
+  }
+  getSleepConfig(name) {
+    if (this.sleepConfigs.has(name)) {
+      return this.sleepConfigs.get(name) ?? null;
+    }
+    const config = this.loadSleepConfig(name);
+    return config;
+  }
+  loadSleepConfig(name) {
+    const dir = mindDir(name);
+    const config = readVoluteConfig(dir);
+    const sleepConfig = config?.sleep ?? null;
+    this.sleepConfigs.set(name, sleepConfig);
+    return sleepConfig;
+  }
+  invalidateSleepConfig(name) {
+    this.sleepConfigs.delete(name);
+  }
+  /**
+   * 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 = await findMind(name);
+      if (!entry) return;
+      const sleepConfig = this.getSleepConfig(name);
+      const wakeAt = opts?.voluntaryWakeAt ?? this.getNextWakeTime(sleepConfig);
+      const wakeTime = formatWakeTime(wakeAt);
+      const preSleepMsg = await getPrompt("pre_sleep", { wakeTime });
+      const { delivered } = await deliverEvent(name, { type: "sleep", body: preSleepMsg });
+      if (delivered) 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);
+      slog.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 manager = getMindManager();
+      if (!manager.isRunning(name)) {
+        try {
+          await wakeMind(name);
+        } catch (err) {
+          await this.handleWakeFailure(name, err);
+          return;
+        }
+      }
+      const entry = await findMind(name);
+      if (!entry) return;
+      this.resetWakeBackoff(name);
+      if (opts?.trigger) {
+        state.wokenByTrigger = true;
+        state.triggerWakeHistory.push({
+          channel: opts.trigger.channel,
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        this.saveState();
+      } else {
+        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 eventsSummary = pendingEventsLine(await pendingEventCount(name));
+        const sleepActivity = [triggerWakeSummary, wakeContext, queuedSummary, eventsSummary].filter(Boolean).join("\n\n");
+        const summaryText = await getPrompt("wake_summary", {
+          currentDate,
+          sleepTime,
+          duration,
+          sleepActivity
+        });
+        await deliverEvent(name, { type: "wake", body: summaryText, force: true });
+        await this.waitForIdle(name, 12e4);
+      }
+      const flushed = await this.flushQueuedMessages(name);
+      if (flushed > 0) {
+        slog.info(`flushed ${flushed} queued message(s) for ${name}`);
+      }
+      const flushedEvents = await flushQueuedEvents(name);
+      if (flushedEvents > 0) {
+        slog.info(`flushed ${flushedEvents} queued event(s) for ${name}`);
+      }
+      if (!opts?.trigger) {
+        this.markAwake(name);
+      }
+      slog.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 { mentions: mentionsEnabled, dms: dmsEnabled } = resolveWakeTriggers(triggers);
+    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,
+      thread: "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 on wake. Rows are grouped by channel
+   * and each channel group is delivered as ONE pre-batched turn (#382) — a night's
+   * backlog becomes one stack per channel, not N cold-start doorbells. Delivery is
+   * all-or-nothing per channel: a failed group's rows stay queued for the next wake,
+   * while other channels still flush.
+   */
+  async flushQueuedMessages(name) {
+    try {
+      const db = await getDb();
+      const rows = await db.select().from(deliveryQueue).where(and(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
+      if (rows.length === 0) return 0;
+      const groups = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        let payload;
+        try {
+          payload = JSON.parse(row.payload);
+        } catch (err) {
+          slog.warn(
+            `dropping unparseable queued message ${row.id} for ${name}`,
+            logger_default.errorData(err)
+          );
+          await db.delete(deliveryQueue).where(eq2(deliveryQueue.id, row.id));
+          continue;
+        }
+        const channel = payload.channel ?? "unknown";
+        if (!groups.has(channel)) groups.set(channel, []);
+        groups.get(channel)?.push({ id: row.id, payload });
+      }
+      let deliveredCount = 0;
+      for (const [channel, items] of groups) {
+        const delivered = await this.deliverQueuedBatch(
+          name,
+          items.map((i) => i.payload)
+        );
+        if (!delivered) {
+          slog.warn(
+            `failed to flush ${items.length} queued message(s) on ${channel} for ${name}; leaving them queued`
+          );
+          continue;
+        }
+        await db.delete(deliveryQueue).where(
+          inArray(
+            deliveryQueue.id,
+            items.map((i) => i.id)
+          )
+        );
+        deliveredCount += items.length;
+      }
+      const state = this.states.get(name);
+      if (state) {
+        state.queuedMessageCount = Math.max(0, state.queuedMessageCount - deliveredCount);
+      }
+      return deliveredCount;
+    } catch (err) {
+      slog.warn(`failed to flush queued messages for ${name}`, logger_default.errorData(err));
+      return 0;
+    }
+  }
+  /**
+   * Deliver one channel's worth of queued messages as a single pre-batched turn on
+   * the wake path. Extracted as a seam so the flush loop can be unit-tested without
+   * the real delivery stack. Returns whether the batch was handed off to the mind.
+   */
+  async deliverQueuedBatch(name, payloads) {
+    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-3456PXB7.js");
+    return deliverBatch2(name, payloads);
+  }
+  // --- Wake failure handling (#419) ---
+  /**
+   * Record a failed wake attempt. Applies exponential backoff between retries and,
+   * after MAX_WAKE_ATTEMPTS consecutive failures, gives up and marks the mind errored
+   * rather than retrying every tick forever.
+   */
+  async handleWakeFailure(name, err) {
+    const state = this.states.get(name);
+    if (!state?.sleeping) return;
+    state.wakeFailures = (state.wakeFailures ?? 0) + 1;
+    if (state.wakeFailures >= MAX_WAKE_ATTEMPTS) {
+      await this.markWakeErrored(name, err);
+      return;
+    }
+    const backoff = WAKE_BACKOFF_MS[Math.min(state.wakeFailures - 1, WAKE_BACKOFF_MS.length - 1)];
+    state.nextWakeAttemptAt = new Date(Date.now() + backoff).toISOString();
+    this.saveState();
+    slog.warn(
+      `failed to wake ${name} (attempt ${state.wakeFailures}/${MAX_WAKE_ATTEMPTS}); retrying in ${Math.round(backoff / 6e4)}m`,
+      logger_default.errorData(err)
+    );
+  }
+  /** Clear wake-failure backoff after a successful wake. */
+  resetWakeBackoff(name) {
+    const state = this.states.get(name);
+    if (!state) return;
+    if (state.wakeFailures === 0 && state.nextWakeAttemptAt === null) return;
+    state.wakeFailures = 0;
+    state.nextWakeAttemptAt = null;
+    this.saveState();
+  }
+  /**
+   * A mind has failed to wake too many times — it isn't asleep, it's broken.
+   * Clear the sleep state (so the tick stops retrying) and surface the failure
+   * loudly: error log, activity event for the web UI, and a mind notice so the
+   * mind learns what happened on its next successful session. A manual
+   * `volute clock wake` / `volute mind start` is the recovery path.
+   */
+  async markWakeErrored(name, err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    this.states.delete(name);
+    this.saveState();
+    slog.error(
+      `${name} failed to wake ${MAX_WAKE_ATTEMPTS} times in a row; giving up and marking errored`,
+      logger_default.errorData(err)
+    );
+    try {
+      await publish({
+        type: "mind_stopped",
+        mind: name,
+        summary: `${name} failed to wake after ${MAX_WAKE_ATTEMPTS} attempts`,
+        metadata: { error: "wake_failed", detail }
+      });
+    } catch (e) {
+      slog.error(`failed to publish wake-failure activity for ${name}`, logger_default.errorData(e));
+    }
+    await recordNotice({
+      mind: name,
+      thread: MIND_LEVEL_THREAD,
+      kind: "startup",
+      reason: "startup_failed",
+      detail: `Wake failed ${MAX_WAKE_ATTEMPTS} times in a row and was given up. Last error: ${detail}`
+    });
+  }
+  // --- Internal methods ---
+  markSleeping(name, opts) {
+    const sleepConfig = this.getSleepConfig(name);
+    const state = {
+      sleeping: true,
+      sleepingSince: (/* @__PURE__ */ new Date()).toISOString(),
+      // An explicit voluntary wake-at is authoritative for the night — null out
+      // the cron wake so an earlier scheduled wake can't silently override it.
+      scheduledWakeAt: opts?.voluntaryWakeAt ? null : this.getNextWakeTime(sleepConfig),
+      wokenByTrigger: false,
+      voluntaryWakeAt: opts?.voluntaryWakeAt ?? null,
+      queuedMessageCount: this.states.get(name)?.queuedMessageCount ?? 0,
+      triggerWakeHistory: [],
+      wakeFailures: 0,
+      nextWakeAttemptAt: null,
+      lastWakeAt: this.states.get(name)?.lastWakeAt ?? null
+    };
+    this.states.set(name, state);
+    this.saveState();
+  }
+  markAwake(name) {
+    this.states.set(name, { ...defaultState(), lastWakeAt: (/* @__PURE__ */ new Date()).toISOString() });
+    this.saveState();
+  }
+  getNextWakeTime(config) {
+    if (!config?.schedule?.wake) return null;
+    try {
+      const interval = CronExpressionParser.parse(config.schedule.wake);
+      return interval.next().toDate().toISOString();
+    } catch (err) {
+      slog.warn(`invalid wake cron "${config.schedule.wake}"`, logger_default.errorData(err));
+      return null;
+    }
+  }
+  async tick() {
+    const now = /* @__PURE__ */ new Date();
+    const mindNames = /* @__PURE__ */ new Set([...this.sleepConfigs.keys(), ...this.states.keys()]);
+    for (const name of mindNames) {
+      await this.evaluateMind(name, now);
+    }
+  }
+  /**
+   * Per-mind tick evaluation. The wake checks depend only on the persisted sleep
+   * state — never on a currently-enabled sleep config — so a mind that was put to
+   * sleep with a wake time still wakes even if the schedule is later disabled or
+   * removed (or never existed, e.g. a bare `clock sleep --wake-at`). Only the
+   * sleep-onset check requires a running mind with an enabled schedule.
+   */
+  async evaluateMind(name, now) {
+    const state = this.states.get(name);
+    if (state?.sleeping) {
+      if (state.nextWakeAttemptAt && now < new Date(state.nextWakeAttemptAt)) return;
+      if (state.voluntaryWakeAt && now >= new Date(state.voluntaryWakeAt)) {
+        this.initiateWake(name).catch(
+          (err) => slog.error(`failed voluntary wake for ${name}`, logger_default.errorData(err))
+        );
+        return;
+      }
+      if (state.scheduledWakeAt && now >= new Date(state.scheduledWakeAt)) {
+        this.initiateWake(name).catch(
+          (err) => slog.error(`failed scheduled wake for ${name}`, logger_default.errorData(err))
+        );
+        return;
+      }
+      return;
+    }
+    const mind = await findMind(name);
+    if (!mind?.running) return;
+    const config = this.getSleepConfig(name);
+    if (!config?.enabled || !config.schedule) return;
+    if (this.shouldSleepNow(config.schedule, state?.lastWakeAt ?? null, now)) {
+      this.initiateSleep(name).catch(
+        (err) => slog.error(`failed to initiate sleep for ${name}`, logger_default.errorData(err))
+      );
+    }
+  }
+  /**
+   * Level-triggered sleep-onset decision: sleep whenever we're inside the nightly
+   * window, not only on the exact sleep minute — so a daemon restart or a stalled
+   * tick across the sleep minute still puts the mind to bed on the next tick.
+   *
+   * Manual-wake exemption: a full wake inside the current window (human
+   * `clock wake`, or a scheduled wake) suppresses re-sleep until the next window
+   * begins, so `volute clock wake` at 3am sticks instead of being undone a minute
+   * later.
+   */
+  shouldSleepNow(schedule, lastWakeAt, now) {
+    const { inWindow, windowStart } = this.inSleepWindow(schedule, now);
+    if (!inWindow || !windowStart) return false;
+    if (lastWakeAt && new Date(lastWakeAt) >= windowStart) return false;
+    return true;
+  }
+  /**
+   * Whether `now` falls inside the mind's nightly sleep window: the most recent
+   * sleep-cron fire is more recent than the most recent wake-cron fire. Returns
+   * the window start (last sleep fire) for the manual-wake exemption check.
+   */
+  inSleepWindow(schedule, now) {
+    try {
+      const prevSleep = CronExpressionParser.parse(schedule.sleep, { currentDate: now }).prev().toDate();
+      const prevWake = CronExpressionParser.parse(schedule.wake, { currentDate: now }).prev().toDate();
+      return { inWindow: prevSleep > prevWake, windowStart: prevSleep };
+    } catch (err) {
+      slog.warn(
+        `invalid sleep/wake cron "${schedule.sleep}"/"${schedule.wake}"`,
+        logger_default.errorData(err)
+      );
+      return { inWindow: false, windowStart: null };
+    }
+  }
+  async waitForIdle(name, timeoutMs) {
+    return new Promise((resolve6) => {
+      const timeout = setTimeout(() => {
+        unsub();
+        resolve6();
+      }, timeoutMs);
+      const unsub = subscribe((event) => {
+        if (event.mind !== name) return;
+        if (event.type === "mind_done" || event.type === "mind_idle") {
+          clearTimeout(timeout);
+          unsub();
+          resolve6();
+        }
+      });
+    });
+  }
+  async archiveSessions(name) {
+    const dir = mindDir(name);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
+    const sessionsDir = resolve4(dir, ".mind", "sessions");
+    if (existsSync4(sessionsDir)) {
+      const archiveDir = resolve4(sessionsDir, "archive");
+      mkdirSync2(archiveDir, { recursive: true });
+      for (const file of readdirSync(sessionsDir)) {
+        if (file === "archive" || !file.endsWith(".json")) continue;
+        const src = resolve4(sessionsDir, file);
+        const base = file.replace(/\.json$/, "");
+        const dest = resolve4(archiveDir, `${base}-${timestamp}.json`);
+        try {
+          renameSync(src, dest);
+        } catch (err) {
+          slog.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
+        }
+      }
+    }
+    const piSessionsDir = resolve4(dir, ".mind", "pi-sessions");
+    if (existsSync4(piSessionsDir)) {
+      const archiveDir = resolve4(piSessionsDir, "archive");
+      mkdirSync2(archiveDir, { recursive: true });
+      for (const entry of readdirSync(piSessionsDir, { withFileTypes: true })) {
+        if (entry.name === "archive" || !entry.isDirectory()) continue;
+        const src = resolve4(piSessionsDir, entry.name);
+        const dest = resolve4(archiveDir, `${entry.name}-${timestamp}`);
+        try {
+          renameSync(src, dest);
+        } catch (err) {
+          slog.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
+        }
+      }
+    }
+  }
+  async runWakeContextScript(name, sleepingSince, duration) {
+    const scriptPath = resolve4(mindDir(name), "home", ".local", "hooks", "wake-context.sh");
+    if (!existsSync4(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) {
+      slog.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, sender: deliveryQueue.sender }).from(deliveryQueue).where(and(eq2(deliveryQueue.mind, name), eq2(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, count]) => `${count} on ${ch}`);
+      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) {
+      slog.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.";
+    }
+  }
+  /**
+   * 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;
+    }
+    slog.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") {
+              slog.warn(`failed to kill orphan pid ${pid}`, logger_default.errorData(err));
+            }
+          }
+        }
+      }
+    } catch {
+      try {
+        const portHex = port.toString(16).toUpperCase().padStart(4, "0");
+        const tcp6 = readFileSync4("/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 readdirSync("/proc").filter((f) => /^\d+$/.test(f))) {
+            try {
+              const fds = readdirSync(`/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) {
+        slog.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") {
+      slog.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;
+        if (!state.voluntaryWakeAt) {
+          const sleepConfig = this.getSleepConfig(event.mind);
+          state.scheduledWakeAt = this.getNextWakeTime(sleepConfig);
+        }
+        this.saveState();
+        slog.info(`${event.mind} returned to sleep`);
+      }).catch((err) => {
+        slog.error(`failed to return ${event.mind} to sleep`, logger_default.errorData(err));
+      }).finally(() => {
+        this.transitioning.delete(event.mind);
+      });
+    }
+  }
+};
+var instance3 = null;
+function initSleepManager() {
+  if (instance3) throw new Error("SleepManager already initialized");
+  instance3 = new SleepManager();
+  return instance3;
+}
+function getSleepManager() {
+  if (!instance3) throw new Error("SleepManager not initialized \u2014 call initSleepManager() first");
+  return instance3;
+}
+function getSleepManagerIfReady() {
+  return instance3;
+}
+
+// packages/daemon/src/lib/delivery/message-delivery.ts
+var dlog = logger_default.child("delivery");
+async function recordInbound(mind, channel, sender, content) {
+  let insertedId;
+  try {
+    const db = await getDb();
+    const result = await db.insert(mindHistory).values({
+      mind,
+      type: "inbound",
+      channel,
+      sender,
+      content
+    }).returning({ id: mindHistory.id });
+    insertedId = result[0]?.id;
+  } catch (err) {
+    dlog.warn(`failed to persist inbound for ${mind}`, logger_default.errorData(err));
+  }
+  publish2(mind, {
+    mind,
+    type: "inbound",
+    channel,
+    content: content ?? void 0,
+    sender: sender ?? void 0
+  });
+  return insertedId;
+}
+async function recordOutbound(mind, channel, content, opts = {}) {
+  try {
+    const db = await getDb();
+    const result = await db.insert(mindHistory).values({
+      mind,
+      type: "outbound",
+      channel,
+      content,
+      turn_id: opts.turnId ?? null,
+      message_id: opts.messageId ?? null
+    }).returning({ id: mindHistory.id });
+    return result[0]?.id;
+  } catch (err) {
+    dlog.warn(`failed to persist outbound for ${mind}`, logger_default.errorData(err));
+    return void 0;
+  }
+}
+var OUTBOUND_MARKER_RE = /\[volute:outbound:(\d+)\]/g;
+var ACTIVITY_MARKER_RE = /\[volute:activity:(\d+)\]/g;
+async function linkToolResultToTurn(mind, turnId, toolResultContent, toolUseEventId) {
+  if (!toolResultContent) return;
+  const db = await getDb();
+  for (const match of toolResultContent.matchAll(OUTBOUND_MARKER_RE)) {
+    const outboundId = Number(match[1]);
+    try {
+      const rows = await db.select({
+        id: mindHistory.id,
+        channel: mindHistory.channel,
+        content: mindHistory.content,
+        message_id: mindHistory.message_id,
+        turn_id: mindHistory.turn_id
+      }).from(mindHistory).where(and2(eq3(mindHistory.id, outboundId), eq3(mindHistory.mind, mind))).limit(1);
+      const row = rows[0];
+      if (!row) {
+        dlog.warn(`outbound marker references missing record: mind=${mind} id=${outboundId}`);
+        continue;
+      }
+      const alreadyTagged = row.turn_id != null;
+      if (!alreadyTagged) {
+        await db.update(mindHistory).set({ turn_id: turnId }).where(eq3(mindHistory.id, outboundId));
+      }
+      if (row.message_id) {
+        await db.update(messages).set({
+          turn_id: turnId,
+          ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
+        }).where(eq3(messages.id, Number(row.message_id)));
+      }
+      if (!alreadyTagged) {
+        publish2(mind, {
+          mind,
+          type: "outbound",
+          channel: row.channel ?? void 0,
+          content: row.content ?? void 0,
+          turnId
+        });
+      }
+    } catch (err) {
+      dlog.warn(`failed to link outbound ${outboundId} to turn ${turnId}`, logger_default.errorData(err));
+    }
+  }
+  const activityIds = [];
+  for (const match of toolResultContent.matchAll(ACTIVITY_MARKER_RE)) {
+    activityIds.push(Number(match[1]));
+  }
+  if (activityIds.length > 0) {
+    try {
+      await db.update(activity).set({
+        turn_id: turnId,
+        ...toolUseEventId != null ? { source_event_id: toolUseEventId } : {}
+      }).where(inArray2(activity.id, activityIds));
+      const actRows = await db.select().from(activity).where(inArray2(activity.id, activityIds));
+      if (actRows.length > 0) {
+        await db.insert(mindHistory).values(
+          actRows.map((a) => ({
+            mind,
+            type: "activity",
+            content: a.summary,
+            metadata: a.metadata,
+            turn_id: turnId,
+            created_at: a.created_at
+          }))
+        );
+      }
+    } catch (err) {
+      dlog.warn(`failed to link activities to turn ${turnId}`, logger_default.errorData(err));
+    }
+  }
+}
+function resolveSleepAction(sleepBehavior, wokenByTrigger, wakeTriggerMatches) {
+  if (sleepBehavior === "skip") return "skip";
+  if (sleepBehavior === "trigger-wake" && !wokenByTrigger) return "queue-and-wake";
+  if (!sleepBehavior && wakeTriggerMatches) return "queue-and-wake";
+  return "queue";
+}
+function willGate(baseName, payload) {
+  if (payload.session) return false;
+  const config = getRoutingConfig(baseName);
+  const route = resolveRoute(config, {
+    channel: payload.channel,
+    sender: payload.sender ?? void 0,
+    isDM: payload.isDM,
+    participantCount: payload.participantCount
+  });
+  return shouldGate(config, route);
+}
+async function deliverMessage(mindName, payload, opts = {}) {
+  try {
+    const baseName = await getBaseName(mindName);
+    const entry = await findMind(baseName);
+    if (!entry) {
+      dlog.warn(`cannot deliver to ${mindName}: mind not found`);
+      return false;
+    }
+    if (!opts.isFlush) {
+      const textContent = extractTextContent(payload.content);
+      const sleepManager = getSleepManagerIfReady();
+      if (sleepManager?.isSleeping(baseName)) {
+        await recordInbound(baseName, payload.channel, payload.sender ?? null, textContent);
+        const sleepState = sleepManager.getState(baseName);
+        const action = resolveSleepAction(
+          payload.whileSleeping,
+          sleepState.wokenByTrigger,
+          sleepManager.checkWakeTrigger(baseName, payload)
+        );
+        if (action === "skip") {
+          dlog.info(
+            `skipped delivery to ${baseName} (sleeping, whileSleeping=skip, channel=${payload.channel})`
+          );
+          return true;
+        }
+        await sleepManager.queueSleepMessage(baseName, payload);
+        if (action === "queue-and-wake") {
+          sleepManager.initiateWake(baseName, { trigger: { channel: payload.channel } }).catch((err) => dlog.warn(`failed to trigger-wake ${baseName}`, logger_default.errorData(err)));
+        }
+        return true;
+      }
+      if (!willGate(baseName, payload)) {
+        await recordInbound(baseName, payload.channel, payload.sender ?? null, textContent);
+      }
+    }
+    const manager = getDeliveryManager();
+    await manager.routeAndDeliver(mindName, payload);
+    return true;
+  } catch (err) {
+    dlog.warn(`unexpected error delivering to ${mindName}`, logger_default.errorData(err));
+    return false;
+  }
+}
+async function deliverBatch(mindName, payloads) {
+  if (payloads.length === 0) return true;
+  try {
+    const baseName = await getBaseName(mindName);
+    const entry = await findMind(baseName);
+    if (!entry) {
+      dlog.warn(`cannot deliver batch to ${mindName}: mind not found`);
+      return false;
+    }
+    const channels = {};
+    for (const p of payloads) {
+      const ch = p.channel ?? "unknown";
+      if (!channels[ch]) channels[ch] = [];
+      channels[ch].push(p);
+    }
+    const first = payloads[0];
+    const route = resolveRoute(getRoutingConfig(baseName), {
+      channel: first.channel,
+      sender: first.sender ?? void 0,
+      isDM: first.isDM,
+      participantCount: first.participantCount
+    });
+    const session = first.session ?? (route.destination === "mind" ? route.session : "main");
+    const res = await fetch(`http://127.0.0.1:${entry.port}/message`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ session, batch: { channels } })
+    });
+    return res.ok;
+  } catch (err) {
+    dlog.warn(`unexpected error delivering batch to ${mindName}`, logger_default.errorData(err));
+    return false;
+  }
+}
+
+// packages/daemon/src/lib/chat/system-channel.ts
+var SYSTEM_CHANNEL_NAME = "system";
+var SYSTEM_CHANNEL_DESCRIPTION = "The commons \u2014 a shared room for every mind and the spirit on this system. Think out loud, check in, riff, coordinate.";
+var cachedChannelId = null;
+async function ensureSystemChannel() {
+  if (cachedChannelId) return cachedChannelId;
+  const existing = await getChannelByName(SYSTEM_CHANNEL_NAME);
+  if (existing) {
+    cachedChannelId = existing.id;
+    const settings = await getChannelSettings(SYSTEM_CHANNEL_NAME);
+    if (settings && settings.description == null) {
+      await updateChannelSettings(SYSTEM_CHANNEL_NAME, {
+        description: SYSTEM_CHANNEL_DESCRIPTION
+      });
+    }
+    return existing.id;
+  }
+  const conv = await createChannel(SYSTEM_CHANNEL_NAME, void 0, {
+    description: SYSTEM_CHANNEL_DESCRIPTION
+  });
+  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 joinSystemChannelForSpirit() {
+  const user = await getOrCreateSystemUser();
+  await joinSystemChannel(user.id);
+}
+async function backfillSystemChannelMembers() {
+  const entries = await readRegistry();
+  for (const entry of entries) {
+    if (entry.stage === "seed") continue;
+    try {
+      if (entry.mindType === "spirit") {
+        await joinSystemChannelForSpirit();
+      } else {
+        await joinSystemChannelForMind(entry.name);
+      }
+    } catch (err) {
+      logger_default.error(`failed to backfill ${entry.name} into #system`, logger_default.errorData(err));
+    }
+  }
+}
+async function announceToSystem(text) {
+  const channelId = await ensureSystemChannel();
+  const systemUser = await getOrCreateSystemUser();
+  await joinChannel(channelId, systemUser.id);
+  await addMessage(channelId, "user", systemUser.username, [{ type: "text", text }]);
+  const participants = await getParticipants(channelId);
+  const mindParticipants = participants.filter((p) => p.userType === "mind");
+  const channel = "#system";
+  for (const mind of mindParticipants) {
+    deliverMessage(mind.username, {
+      content: [{ type: "text", text }],
+      channel,
+      conversationId: channelId,
+      sender: systemUser.username,
+      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));
+    });
+  }
+}
+async function announceSprout(mindName) {
+  const displayName = (await getUserByUsername(mindName).catch(() => null))?.display_name ?? mindName;
+  await deliverEvent(getSpiritName(), {
+    type: "lifecycle",
+    meta: { subtype: "sprout-welcome", mind: mindName },
+    body: `${displayName} (@${mindName}) has just sprouted into a full mind and joined #system. Welcome them there in your own words.`
+  });
+  await publish({
+    type: "mind_sprouted",
+    mind: mindName,
+    summary: `${displayName} sprouted`
+  }).catch(
+    (err) => logger_default.warn(`failed to publish sprout activity for ${mindName}`, logger_default.errorData(err))
+  );
+}
+
+// packages/daemon/src/lib/util/sanitize-svg.ts
+import DOMPurify from "isomorphic-dompurify";
+var ALLOWED_TAGS = ["svg", "path", "circle", "rect", "line", "polyline", "polygon", "g"];
+var ALLOWED_ATTR = [
+  "viewBox",
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-dasharray",
+  "stroke-opacity",
+  "opacity",
+  "d",
+  "cx",
+  "cy",
+  "r",
+  "x",
+  "y",
+  "width",
+  "height",
+  "points",
+  "transform"
+];
+function sanitizeSvgIcon(html) {
+  return DOMPurify.sanitize(html, {
+    ALLOWED_TAGS,
+    ALLOWED_ATTR,
+    FORBID_TAGS: ["script", "foreignObject"],
+    FORBID_ATTR: ["href", "xlink:href"]
+  });
+}
+
+// packages/daemon/src/lib/extensions.ts
+var VALID_EXTENSION_ID = /^[a-z0-9][a-z0-9_-]*$/;
+var loaded = [];
+var discovered = [];
+function enrichActivityMetadata(manifest, metadata) {
+  const enriched = {
+    ...metadata,
+    ...manifest.icon && !metadata?.icon ? { icon: manifest.icon } : {},
+    ...manifest.color && !metadata?.color ? { color: manifest.color } : {}
+  };
+  if (typeof enriched.icon === "string") enriched.icon = sanitizeSvgIcon(enriched.icon);
+  return enriched;
+}
+function toCommandInfo(cmd) {
+  const { handler: _, ...info } = cmd;
+  return info;
+}
+function parseCommandArgs(rawArgs, argDefs, flagDefs) {
+  const positional = [];
+  const flags = {};
+  for (const [key, def] of Object.entries(flagDefs)) {
+    flags[key] = def.type === "boolean" ? false : void 0;
+  }
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg.startsWith("--")) {
+      const name = arg.slice(2);
+      const def = flagDefs[name];
+      if (!def) {
+        logger_default.warn(`unknown flag --${name}`);
+        continue;
+      }
+      if (def.type === "boolean") {
+        flags[name] = true;
+      } else if (i + 1 < rawArgs.length) {
+        const val = rawArgs[++i];
+        if (def.type === "number") {
+          const n = parseInt(val, 10);
+          flags[name] = Number.isNaN(n) ? void 0 : n;
+        } else {
+          flags[name] = val;
+        }
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  const namedArgs = {};
+  for (let i = 0; i < argDefs.length; i++) {
+    namedArgs[argDefs[i].name] = positional[i];
+  }
+  const rest = positional.slice(argDefs.length);
+  return { args: namedArgs, flags, rest };
+}
+function extensionsBaseDir() {
+  return resolve5(voluteHome(), "extensions");
+}
+function extensionDataDir(id) {
+  return resolve5(voluteSystemDir(), "extension-data", id);
+}
+function extensionsConfigPath() {
+  return resolve5(voluteHome(), "system", "extensions.json");
+}
+function readExtensionsConfig() {
+  const configPath2 = extensionsConfigPath();
+  if (!existsSync5(configPath2)) return [];
+  try {
+    const data = JSON.parse(readFileSync5(configPath2, "utf-8"));
+    return Array.isArray(data) ? data : [];
+  } catch (err) {
+    logger_default.warn("failed to read extensions config, ignoring installed extensions", {
+      path: configPath2,
+      error: err.message
+    });
+    return [];
+  }
+}
+var _LibsqlDatabase = null;
+async function getLibsqlDatabase() {
+  if (_LibsqlDatabase) return _LibsqlDatabase;
+  const mod = await import("libsql");
+  _LibsqlDatabase = mod.default ?? mod;
+  return _LibsqlDatabase;
+}
+async function openExtensionDb(_id, dataDir) {
+  const dbPath = resolve5(dataDir, "data.db");
+  const Database = await getLibsqlDatabase();
+  return new Database(dbPath);
+}
+async function buildContext(manifest, dataDir, authMw) {
+  let db = null;
+  if (manifest.initDb) {
+    const realDb = await openExtensionDb(manifest.id, dataDir);
+    try {
+      manifest.initDb(realDb);
+    } catch (err) {
+      realDb.close();
+      throw new Error(`initDb failed for extension ${manifest.id}: ${err.message}`);
+    }
+    db = realDb;
+  }
+  return {
+    db,
+    authMiddleware: authMw,
+    // Reuse the daemon's canonical guard so extension routes authorize the same
+    // way core routes do (admin/system or the mind whose base name matches the
+    // route param). Its type is compatible with the SDK MiddlewareHandler.
+    requireSelf: (paramName) => requireSelf(paramName),
+    resolveUser: (c) => {
+      const user = c.get("user");
+      if (!user || typeof user !== "object") return null;
+      return user;
+    },
+    getUser: async (id) => getUser(id),
+    getUserByUsername: async (username) => getUserByUsername(username),
+    publishActivity: (event) => {
+      const metadata = enrichActivityMetadata(manifest, event.metadata);
+      const enriched = { ...event, metadata };
+      publish(enriched).catch(
+        (err) => logger_default.error(`extension ${manifest.id}: failed to publish activity`, logger_default.errorData(err))
+      );
+    },
+    getMindDir: (name) => {
+      try {
+        const dir = mindDir(name);
+        return existsSync5(dir) ? dir : null;
+      } catch (err) {
+        logger_default.warn(
+          `extension ${manifest.id}: failed to resolve mind dir for ${name}`,
+          logger_default.errorData(err)
+        );
+        return null;
+      }
+    },
+    getSystemsConfig: () => readSystemsConfig(),
+    announceToSystem: (text) => announceToSystem(text),
+    recordNotice: async (mindName, text) => {
+      try {
+        const user = await getUserByUsername(mindName);
+        if (user?.user_type !== "mind") return;
+        await recordNotice({
+          mind: mindName,
+          thread: MIND_LEVEL_THREAD,
+          kind: "extension",
+          reason: manifest.id,
+          detail: text.slice(0, 500)
+        });
+      } catch (err) {
+        logger_default.warn(
+          `extension ${manifest.id}: failed to record notice for ${mindName}`,
+          logger_default.errorData(err)
+        );
+      }
+    },
+    isIsolationEnabled,
+    getMindUser: mindUserName,
+    dataDir
+  };
+}
+async function loadExtension(manifest, app, authMw) {
+  if (!VALID_EXTENSION_ID.test(manifest.id)) {
+    logger_default.error(`invalid extension ID "${manifest.id}", skipping (must match ${VALID_EXTENSION_ID})`);
+    return;
+  }
+  const dataDir = extensionDataDir(manifest.id);
+  mkdirSync3(dataDir, { recursive: true });
+  const context = await buildContext(manifest, dataDir, authMw);
+  const routesApp = manifest.routes(context);
+  const extApiPath = `/api/ext/${manifest.id}`;
+  app.use(extApiPath, authMw);
+  app.use(`${extApiPath}/*`, authMw);
+  app.route(extApiPath, routesApp);
+  if (manifest.publicRoutes) {
+    const publicApp = manifest.publicRoutes(context);
+    app.route(`/ext/${manifest.id}/public`, publicApp);
+  }
+  if (manifest.commands) {
+    for (const [cmdName, cmd] of Object.entries(manifest.commands)) {
+      app.post(`${extApiPath}/commands/${cmdName}`, async (c) => {
+        let body;
+        try {
+          body = await c.req.json();
+        } catch {
+          return c.json({ error: "Invalid JSON in request body" }, 400);
+        }
+        const user = c.get("user");
+        const privileged = user?.role === "admin" || user?.role === "system";
+        const mindName = privileged ? body.mind || user?.username : user?.username;
+        const session = c.get("mindSession");
+        try {
+          const activityPromises = [];
+          const parsed = parseCommandArgs(body.args ?? [], cmd.args ?? [], cmd.flags ?? {});
+          const result = await cmd.handler(parsed, {
+            ...context,
+            publishActivity: (rawEvent) => {
+              const metadata = enrichActivityMetadata(manifest, rawEvent.metadata);
+              const event = { ...rawEvent, metadata };
+              activityPromises.push(
+                publish(event).catch((err) => {
+                  logger_default.error(
+                    `extension ${manifest.id}: failed to publish activity`,
+                    logger_default.errorData(err)
+                  );
+                  return 0;
+                })
+              );
+            },
+            mindName,
+            session,
+            stdin: body.stdin
+          });
+          const activityIds = (await Promise.all(activityPromises)).filter((id) => id > 0);
+          const markers = activityIds.map((id) => `[volute:activity:${id}]`).join("");
+          const output = result && typeof result === "object" && "output" in result ? { ...result, output: `${result.output}${markers}` } : markers ? { ...result, output: markers } : result;
+          return c.json(output);
+        } catch (err) {
+          logger_default.error(`extension command ${manifest.id}/${cmdName} failed`, logger_default.errorData(err));
+          return c.json({ error: err.message }, 500);
+        }
+      });
+    }
+  }
+  let resolvedAssetsDir = manifest.ui?.assetsDir ?? "";
+  if (resolvedAssetsDir && !existsSync5(resolvedAssetsDir)) {
+    let searchDir = dirname(new URL(import.meta.url).pathname);
+    for (let i = 0; i < 5; i++) {
+      const candidate = resolve5(searchDir, "packages", "extensions", manifest.id, "dist", "ui");
+      if (existsSync5(candidate)) {
+        resolvedAssetsDir = candidate;
+        break;
+      }
+      searchDir = dirname(searchDir);
+    }
+  }
+  if (resolvedAssetsDir && existsSync5(resolvedAssetsDir)) {
+    const assetsDir = resolvedAssetsDir;
+    const { readFile, stat: fsStat } = await import("fs/promises");
+    const { extname: ext } = await import("path");
+    const mimeTypes = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2"
+    };
+    const prefix = `/ext/${manifest.id}`;
+    const indexPath = resolve5(assetsDir, "index.html");
+    const serveExtAssets = async (c) => {
+      const urlPath = new URL(c.req.url).pathname;
+      const relativePath = urlPath.slice(prefix.length).replace(/^\//, "") || "index.html";
+      const filePath = resolve5(assetsDir, relativePath);
+      if (filePath !== assetsDir && !filePath.startsWith(`${assetsDir}/`))
+        return c.text("Forbidden", 403);
+      const s = await fsStat(filePath).catch(() => null);
+      if (s?.isFile()) {
+        const mime = mimeTypes[ext(filePath)] || "application/octet-stream";
+        const body = await readFile(filePath);
+        return c.body(body, 200, { "Content-Type": mime });
+      }
+      if (existsSync5(indexPath)) {
+        const body = await readFile(indexPath, "utf-8");
+        return c.html(body);
+      }
+      return c.text("Not found", 404);
+    };
+    app.get(`${prefix}/*`, serveExtAssets);
+    app.get(prefix, serveExtAssets);
+  }
+  const skillsDir = resolveSkillsDir(manifest);
+  if (skillsDir) {
+    let entries;
+    try {
+      entries = readdirSync2(skillsDir, { withFileTypes: true });
+    } catch (err) {
+      logger_default.error(`failed to read skills dir for extension ${manifest.id}`, logger_default.errorData(err));
+      entries = [];
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const skillPath = resolve5(skillsDir, entry.name);
+        const sourceHash = hashSkillDir(skillPath);
+        const destDir = resolve5(sharedSkillsDir(), entry.name);
+        if (existsSync5(destDir)) {
+          const destHash = hashSkillDir(destDir);
+          if (sourceHash === destHash) continue;
+        }
+        await importSkillFromDir(skillPath, `ext:${manifest.id}`);
+        logger_default.info(`synced skill "${entry.name}" for extension: ${manifest.id}`);
+      } catch (err) {
+        logger_default.error(
+          `failed to sync skill "${entry.name}" for extension ${manifest.id}`,
+          logger_default.errorData(err)
+        );
+      }
+    }
+  }
+  if (manifest.standardSkill && !manifest.skillsDir) {
+    logger_default.warn(`extension ${manifest.id}: standardSkill is true but no skillsDir declared`);
+  }
+  loaded.push({ manifest, context });
+  logger_default.info(`loaded extension: ${manifest.id} v${manifest.version}`);
+}
+var skillsDirCache = /* @__PURE__ */ new Map();
+function resolveSkillsDir(manifest) {
+  if (!manifest.skillsDir) return null;
+  const cached = skillsDirCache.get(manifest.id);
+  if (cached !== void 0) return cached;
+  let searchDir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve5(searchDir, "packages", "extensions", manifest.id, "skills");
+    if (existsSync5(candidate)) {
+      skillsDirCache.set(manifest.id, candidate);
+      return candidate;
+    }
+    searchDir = dirname(searchDir);
+  }
+  if (existsSync5(manifest.skillsDir)) {
+    skillsDirCache.set(manifest.id, manifest.skillsDir);
+    return manifest.skillsDir;
+  }
+  logger_default.warn(`skills dir not found for extension ${manifest.id}: ${manifest.skillsDir}`);
+  skillsDirCache.set(manifest.id, null);
+  return null;
+}
+async function discoverBuiltinExtensions(disabledIds) {
+  const builtins = [
+    { id: "notes", load: async () => (await import("./src-HGNE2XG4.js")).default },
+    { id: "pages", load: async () => (await import("./src-LCSOQY6Z.js")).default },
+    { id: "plan", load: async () => (await import("./src-UDMJZ6MH.js")).default }
+  ];
+  const results = [];
+  for (const { id, load } of builtins) {
+    if (disabledIds.has(id)) continue;
+    try {
+      results.push(await load());
+    } catch (err) {
+      logger_default.error(`failed to load built-in extension: ${id}`, logger_default.errorData(err));
+    }
+  }
+  return results;
+}
+async function discoverInstalledExtensions() {
+  const results = [];
+  const packages = readExtensionsConfig();
+  const npmDir = resolve5(voluteHome(), "extensions", "_npm");
+  const { createRequire } = await import("module");
+  for (const pkg of packages) {
+    try {
+      let resolved = pkg;
+      const npmPkgDir = resolve5(npmDir, "node_modules", pkg);
+      if (existsSync5(npmPkgDir)) {
+        const require2 = createRequire(resolve5(npmDir, "noop.js"));
+        resolved = require2.resolve(pkg);
+      }
+      const mod = await import(resolved);
+      const manifest = mod.default ?? mod.extension ?? mod;
+      if (!validateManifest(manifest, `package ${pkg}`)) continue;
+      results.push({ manifest, package: pkg });
+    } catch (err) {
+      logger_default.error(`failed to load extension package: ${pkg}`, logger_default.errorData(err));
+    }
+  }
+  return results;
+}
+function validateManifest(manifest, source) {
+  if (!manifest || typeof manifest !== "object") {
+    logger_default.warn(`extension from ${source} does not export a valid manifest`);
+    return false;
+  }
+  const m = manifest;
+  if (!m.id || typeof m.id !== "string") {
+    logger_default.warn(`extension from ${source} is missing a valid id`);
+    return false;
+  }
+  if (!VALID_EXTENSION_ID.test(m.id)) {
+    logger_default.warn(`extension from ${source} has invalid id "${m.id}"`);
+    return false;
+  }
+  if (typeof m.routes !== "function") {
+    logger_default.warn(`extension from ${source} is missing a routes function`);
+    return false;
+  }
+  if (!m.name || typeof m.name !== "string") {
+    logger_default.warn(`extension "${m.id}" from ${source} is missing a name`);
+    return false;
+  }
+  if (!m.version || typeof m.version !== "string") {
+    logger_default.warn(`extension "${m.id}" from ${source} is missing a version`);
+    return false;
+  }
+  return true;
+}
+async function discoverLocalExtensions() {
+  const baseDir = extensionsBaseDir();
+  if (!existsSync5(baseDir)) return [];
+  const manifests = [];
+  let entries;
+  try {
+    entries = readdirSync2(baseDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== "_npm").map((d) => d.name);
+  } catch (err) {
+    logger_default.error("failed to read local extensions directory", logger_default.errorData(err));
+    return [];
+  }
+  for (const dir of entries) {
+    const extDir = resolve5(baseDir, dir);
+    const candidates = [resolve5(extDir, "src", "index.js"), resolve5(extDir, "index.js")];
+    const entryPoint = candidates.find((p) => existsSync5(p));
+    if (!entryPoint) continue;
+    try {
+      const mod = await import(entryPoint);
+      const manifest = mod.default ?? mod.extension ?? mod;
+      if (!validateManifest(manifest, `local dir ${extDir}`)) continue;
+      manifests.push(manifest);
+      logger_default.info(`discovered local extension: ${manifest.id} from ${extDir}`);
+    } catch (err) {
+      logger_default.error(`failed to load local extension from ${extDir}`, logger_default.errorData(err));
+    }
+  }
+  return manifests;
+}
+async function loadAllExtensions(app, authMw) {
+  const disabledIds = new Set(readGlobalConfig().disabledExtensions ?? []);
+  const builtins = await discoverBuiltinExtensions(disabledIds);
+  const installed = await discoverInstalledExtensions();
+  const local = await discoverLocalExtensions();
+  const all = [
+    ...builtins.map((m) => ({ manifest: m, source: "builtin" })),
+    ...installed.map((i) => ({ manifest: i.manifest, source: "npm", package: i.package })),
+    ...local.map((m) => ({ manifest: m, source: "local" }))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of all) {
+    const { manifest } = entry;
+    if (seen.has(manifest.id)) {
+      logger_default.warn(`duplicate extension ID: ${manifest.id}, skipping`);
+      continue;
+    }
+    seen.add(manifest.id);
+    discovered.push(entry);
+    if (disabledIds.has(manifest.id)) {
+      logger_default.info(`extension disabled, skipping: ${manifest.id}`);
+      continue;
+    }
+    try {
+      await loadExtension(manifest, app, authMw);
+    } catch (err) {
+      logger_default.error(`failed to load extension: ${manifest.id}`, logger_default.errorData(err));
+    }
+  }
+  app.get("/api/extensions/commands", (c) => {
+    const result = {};
+    for (const { manifest } of loaded) {
+      if (!manifest.commands) continue;
+      const cmds = {};
+      for (const [name, cmd] of Object.entries(manifest.commands)) {
+        cmds[name] = toCommandInfo(cmd);
+      }
+      result[manifest.id] = { commands: cmds };
+    }
+    return c.json(result);
+  });
+  app.get("/api/extensions/mind-docs", (c) => {
+    const result = loaded.filter(({ manifest }) => manifest.mindDoc || manifest.commands).map(({ manifest }) => ({
+      id: manifest.id,
+      name: manifest.name,
+      mindDoc: manifest.mindDoc ?? manifest.description ?? "",
+      commands: Object.keys(manifest.commands ?? {})
+    }));
+    return c.json(result);
+  });
+}
+function getLoadedExtensions() {
+  return loaded.map(({ manifest }) => {
+    let commands;
+    if (manifest.commands) {
+      commands = {};
+      for (const [name, cmd] of Object.entries(manifest.commands)) {
+        commands[name] = toCommandInfo(cmd);
+      }
+    }
+    return {
+      id: manifest.id,
+      name: manifest.name,
+      version: manifest.version,
+      description: manifest.description,
+      icon: manifest.icon,
+      systemSection: manifest.ui?.systemSection,
+      mindSections: manifest.ui?.mindSections,
+      feedSource: manifest.ui?.feedSource,
+      commands
+    };
+  });
+}
+function getAllDiscoveredExtensions() {
+  const disabledIds = new Set(readGlobalConfig().disabledExtensions ?? []);
+  return discovered.map((d) => ({
+    id: d.manifest.id,
+    name: d.manifest.name,
+    version: d.manifest.version,
+    description: d.manifest.description,
+    icon: d.manifest.icon,
+    source: d.source,
+    enabled: !disabledIds.has(d.manifest.id),
+    package: d.package
+  }));
+}
+function getAllDiscoveredExtensionsDetailed() {
+  const basic = getAllDiscoveredExtensions();
+  const loadedMap = new Map(loaded.map((l) => [l.manifest.id, l.manifest]));
+  return basic.map((ext) => {
+    const manifest = loadedMap.get(ext.id);
+    if (!manifest) return ext;
+    const detail = { ...ext };
+    const skillsDir = resolveSkillsDir(manifest);
+    if (skillsDir) {
+      try {
+        detail.skills = readdirSync2(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          logger_default.warn(`failed to read skills dir for ${ext.id}`, logger_default.errorData(err));
+        }
+      }
+    }
+    if (manifest.commands) {
+      detail.commands = {};
+      for (const [name, cmd] of Object.entries(manifest.commands)) {
+        detail.commands[name] = toCommandInfo(cmd);
+      }
+    }
+    if (manifest.ui?.mindSections) detail.mindSections = manifest.ui.mindSections;
+    if (manifest.ui?.systemSection) detail.systemSection = manifest.ui.systemSection;
+    if (manifest.standardSkill) detail.standardSkill = true;
+    return detail;
+  });
+}
+function setExtensionEnabled(id, enabled) {
+  if (!discovered.find((d) => d.manifest.id === id)) {
+    throw new Error(`Extension "${id}" not found`);
+  }
+  const config = readGlobalConfig();
+  const disabled = new Set(config.disabledExtensions ?? []);
+  if (enabled) {
+    disabled.delete(id);
+  } else {
+    disabled.add(id);
+  }
+  config.disabledExtensions = disabled.size > 0 ? [...disabled] : void 0;
+  writeGlobalConfig(config);
+}
+function extensionsNpmDir() {
+  return resolve5(voluteHome(), "extensions", "_npm");
+}
+function ensureExtensionsNpmDir() {
+  const dir = extensionsNpmDir();
+  mkdirSync3(dir, { recursive: true });
+  const pkgPath = resolve5(dir, "package.json");
+  if (!existsSync5(pkgPath)) {
+    writeFileSync3(pkgPath, '{"private":true,"dependencies":{}}\n');
+  }
+  return dir;
+}
+function writeExtensionsConfig(packages) {
+  const configPath2 = extensionsConfigPath();
+  mkdirSync3(resolve5(configPath2, ".."), { recursive: true });
+  writeFileSync3(configPath2, `${JSON.stringify(packages, null, 2)}
+`);
+}
+var VALID_NPM_PACKAGE = /^(@[a-z0-9-~][a-z0-9._-~]*\/)?[a-z0-9-~][a-z0-9._-~]*(@[^\s]+)?$/;
+async function installNpmExtension(pkg) {
+  if (!VALID_NPM_PACKAGE.test(pkg)) {
+    throw new Error(`Invalid package name: "${pkg}"`);
+  }
+  const packages = readExtensionsConfig();
+  if (packages.includes(pkg)) {
+    throw new Error(`Extension "${pkg}" is already installed`);
+  }
+  const dir = ensureExtensionsNpmDir();
+  const { exec } = await import("./exec-2H65LMTA.js");
+  try {
+    await exec("npm", ["install", "--ignore-scripts", pkg], { cwd: dir });
+  } catch (err) {
+    logger_default.error(`npm install failed for "${pkg}"`, logger_default.errorData(err));
+    throw new Error(`Failed to install "${pkg}". Check daemon logs for details.`);
+  }
+  packages.push(pkg);
+  writeExtensionsConfig(packages);
+  logger_default.info(`installed extension package: ${pkg}`);
+}
+async function uninstallNpmExtension(pkg) {
+  const packages = readExtensionsConfig();
+  const idx = packages.indexOf(pkg);
+  if (idx === -1) {
+    throw new Error(`Extension "${pkg}" is not installed`);
+  }
+  await cleanupExtensionSkills(pkg);
+  packages.splice(idx, 1);
+  writeExtensionsConfig(packages);
+  try {
+    const { exec } = await import("./exec-2H65LMTA.js");
+    await exec("npm", ["uninstall", "--ignore-scripts", pkg], { cwd: extensionsNpmDir() });
+  } catch (err) {
+    logger_default.warn(
+      `npm uninstall failed for "${pkg}" (may have been manually removed)`,
+      logger_default.errorData(err)
+    );
+  }
+  logger_default.info(`uninstalled extension package: ${pkg}`);
+}
+async function cleanupExtensionSkills(pkg) {
+  try {
+    const pkgDir = resolve5(extensionsNpmDir(), "node_modules", pkg);
+    if (!existsSync5(pkgDir)) return;
+    const { createRequire } = await import("module");
+    const require2 = createRequire(resolve5(extensionsNpmDir(), "noop.js"));
+    const mod = require2(pkg);
+    const manifest = mod.default ?? mod.extension ?? mod;
+    if (!manifest?.skillsDir || !existsSync5(manifest.skillsDir)) return;
+    const skillDirs = readdirSync2(manifest.skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    for (const skillId of skillDirs) {
+      try {
+        await removeSharedSkill(skillId);
+        logger_default.info(`removed skill "${skillId}" from extension ${pkg}`);
+      } catch (err) {
+        logger_default.warn(`failed to remove skill "${skillId}" for extension ${pkg}`, logger_default.errorData(err));
+      }
+    }
+  } catch (err) {
+    logger_default.warn(`could not clean up skills for "${pkg}"`, logger_default.errorData(err));
+  }
+}
+function getExtensionStandardSkills() {
+  const skills = [];
+  for (const { manifest } of loaded) {
+    if (!manifest.standardSkill) continue;
+    const dir = resolveSkillsDir(manifest);
+    if (!dir) continue;
+    try {
+      for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) skills.push(entry.name);
+      }
+    } catch (err) {
+      logger_default.warn(`failed to read skills dir for extension ${manifest.id}`, logger_default.errorData(err));
+    }
+  }
+  return skills;
+}
+function notifyExtensionsDaemonStart() {
+  for (const { manifest, context } of loaded) {
+    try {
+      manifest.onDaemonStart?.(context);
+    } catch (err) {
+      logger_default.error(`extension ${manifest.id}: onDaemonStart failed`, logger_default.errorData(err));
+    }
+  }
+}
+function notifyExtensionsDaemonStop() {
+  for (const { manifest, context } of loaded) {
+    try {
+      manifest.onDaemonStop?.();
+    } catch (err) {
+      logger_default.error(`extension ${manifest.id}: onDaemonStop failed`, logger_default.errorData(err));
+    }
+    try {
+      context.db?.close();
+    } catch (err) {
+      logger_default.warn(`extension ${manifest.id}: failed to close db`, logger_default.errorData(err));
+    }
+  }
+  loaded.length = 0;
+  discovered.length = 0;
+  skillsDirCache.clear();
+}
+function notifyExtensionsMindStart(mindName) {
+  for (const { manifest, context } of loaded) {
+    try {
+      manifest.onMindStart?.(mindName, context);
+    } catch (err) {
+      logger_default.error(`extension ${manifest.id}: onMindStart failed for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+}
+function notifyExtensionsMindStop(mindName) {
+  for (const { manifest } of loaded) {
+    try {
+      manifest.onMindStop?.(mindName);
+    } catch (err) {
+      logger_default.error(`extension ${manifest.id}: onMindStop failed for ${mindName}`, logger_default.errorData(err));
+    }
+  }
+}
+
+export {
+  invalidateMindUserCache,
+  SESSION_MAX_AGE,
+  invalidateSessionCache,
+  createSession,
+  deleteSession,
+  getSessionUserId,
+  cleanExpiredSessions,
+  requireAdmin,
+  requireAdminOrSystem,
+  authMiddleware,
+  requireSelf,
+  readSystemsConfig,
+  writeSystemsConfig,
+  deleteSystemsConfig,
+  enrichActivityMetadata,
+  parseCommandArgs,
+  loadAllExtensions,
+  getLoadedExtensions,
+  getAllDiscoveredExtensions,
+  getAllDiscoveredExtensionsDetailed,
+  setExtensionEnabled,
+  installNpmExtension,
+  uninstallNpmExtension,
+  getExtensionStandardSkills,
+  notifyExtensionsDaemonStart,
+  notifyExtensionsDaemonStop,
+  notifyExtensionsMindStart,
+  notifyExtensionsMindStop,
+  initMailPoller,
+  initTokenBudget,
+  getTokenBudget,
+  startMindFull,
+  recordMissingCredentialsNotice,
+  sleepMind,
+  wakeMind,
+  startSpiritFull,
+  stopSpiritFull,
+  buildSeedOrientation,
+  stopMindFull,
+  matchesGlob,
+  SleepManager,
+  initSleepManager,
+  getSleepManager,
+  getSleepManagerIfReady,
+  recordInbound,
+  recordOutbound,
+  linkToolResultToTurn,
+  resolveSleepAction,
+  deliverMessage,
+  deliverBatch,
+  ensureSystemChannel,
+  joinSystemChannel,
+  joinSystemChannelForMind,
+  backfillSystemChannelMembers,
+  announceToSystem,
+  announceSprout
+};