volute 0.28.0 → 0.30.0

package/dist/{chunk-AAPXKR5V.js → chunk-QVAQ5454.js}

@@ -1,4 +1,14 @@
 #!/usr/bin/env node
+import {
+  markIdle
+} from "./chunk-FSM45XD5.js";
+import {
+  clearJsonMap,
+  getMindManager,
+  getPrompt,
+  loadJsonMap,
+  saveJsonMap
+} from "./chunk-LIRWLNAK.js";
 import {
   addMessage,
   createChannel,
@@ -6,28 +16,24 @@ import {
   getParticipants,
   joinChannel,
   publish as publish2
-} from "./chunk-IAYBDWVG.js";
+} from "./chunk-2C2VXEBB.js";
 import {
-  markIdle
-} from "./chunk-K5NAC55T.js";
+  getOrCreateMindUser,
+  notifyExtensionsMindStart,
+  notifyExtensionsMindStop,
+  readSystemsConfig,
+  syncMindProfile
+} from "./chunk-2NDZC3S7.js";
 import {
-  broadcast,
   publish,
   subscribe
-} from "./chunk-VIVMW2H2.js";
-import {
-  clearJsonMap,
-  getMindManager,
-  getPrompt,
-  loadJsonMap,
-  saveJsonMap
-} from "./chunk-POSXWWTA.js";
+} from "./chunk-P27RV5WM.js";
 import {
   logger_default
 } from "./chunk-YUIHSKR6.js";
 import {
   exec
-} from "./chunk-AW7PFDVN.js";
+} from "./chunk-CVH6Y2YG.js";
 import {
   deliveryQueue,
   findMind,
@@ -37,27 +43,25 @@ import {
   mindHistory,
   readRegistry,
   stateDir,
-  users,
   voluteHome,
-  voluteSystemDir,
-  voluteUserHome
-} from "./chunk-H7OZRFJB.js";
+  voluteSystemDir
+} from "./chunk-HHTXM4JT.js";
 
 // src/lib/daemon/sleep-manager.ts
 import { execFile, spawn as spawnChild } from "child_process";
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync6,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readdirSync,
+  readFileSync as readFileSync5,
   readlinkSync,
-  renameSync as renameSync2,
-  writeFileSync as writeFileSync5
+  renameSync,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { resolve as resolve9 } from "path";
+import { resolve as resolve7 } from "path";
 import { promisify } from "util";
 import { CronExpressionParser as CronExpressionParser2 } from "cron-parser";
-import { and as and3, eq as eq3, inArray as inArray2 } from "drizzle-orm";
+import { and as and2, eq as eq2, inArray } from "drizzle-orm";
 
 // src/lib/volute-config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -95,344 +99,9 @@ function writeVoluteConfig(mindDir2, config) {
 `);
 }
 
-// src/lib/auth.ts
-import { compareSync, hashSync } from "bcryptjs";
-import { and, count, eq, inArray } from "drizzle-orm";
-var userSelectFields = {
-  id: users.id,
-  username: users.username,
-  role: users.role,
-  user_type: users.user_type,
-  display_name: users.display_name,
-  description: users.description,
-  avatar: users.avatar,
-  created_at: users.created_at
-};
-async function createUser(username, password) {
-  const db = await getDb();
-  const hash = hashSync(password, 10);
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.user_type, "brain"));
-  const role = value === 0 ? "admin" : "pending";
-  const [result] = await db.insert(users).values({ username, password_hash: hash, role }).returning(userSelectFields);
-  return result;
-}
-async function verifyUser(username, password) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.username, username)).get();
-  if (!row) return null;
-  if (row.user_type === "mind") return null;
-  if (!compareSync(password, row.password_hash)) return null;
-  const { password_hash: _, ...user } = row;
-  return user;
-}
-async function getUser(id) {
-  const db = await getDb();
-  const row = await db.select(userSelectFields).from(users).where(eq(users.id, id)).get();
-  return row ?? null;
-}
-async function getUserByUsername(username) {
-  const db = await getDb();
-  const row = await db.select(userSelectFields).from(users).where(eq(users.username, username)).get();
-  return row ?? null;
-}
-async function listUsers() {
-  const db = await getDb();
-  return db.select(userSelectFields).from(users).orderBy(users.created_at).all();
-}
-async function listPendingUsers() {
-  const db = await getDb();
-  return db.select(userSelectFields).from(users).where(eq(users.role, "pending")).orderBy(users.created_at).all();
-}
-async function listUsersByType(userType) {
-  const db = await getDb();
-  return db.select(userSelectFields).from(users).where(eq(users.user_type, userType)).orderBy(users.created_at).all();
-}
-async function getOrCreateMindUser(mindName) {
-  const db = await getDb();
-  const existing = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-  if (existing) return existing;
-  try {
-    const [result] = await db.insert(users).values({
-      username: mindName,
-      password_hash: "!mind",
-      role: "user",
-      user_type: "mind"
-    }).returning(userSelectFields);
-    return result;
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-      const retried = await db.select(userSelectFields).from(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind"))).get();
-      if (retried) return retried;
-    }
-    throw err;
-  }
-}
-async function deleteMindUser(mindName) {
-  const db = await getDb();
-  await db.delete(users).where(and(eq(users.username, mindName), eq(users.user_type, "mind")));
-}
-async function changePassword(userId, currentPassword, newPassword) {
-  const db = await getDb();
-  const row = await db.select().from(users).where(eq(users.id, userId)).get();
-  if (!row) return false;
-  if (!compareSync(currentPassword, row.password_hash)) return false;
-  const hash = hashSync(newPassword, 10);
-  await db.update(users).set({ password_hash: hash }).where(eq(users.id, userId));
-  return true;
-}
-async function approveUser(id) {
-  const db = await getDb();
-  await db.update(users).set({ role: "user" }).where(and(eq(users.id, id), eq(users.role, "pending")));
-}
-async function countAdmins() {
-  const db = await getDb();
-  const [{ value }] = await db.select({ value: count() }).from(users).where(eq(users.role, "admin"));
-  return value;
-}
-async function setUserRole(id, role) {
-  const db = await getDb();
-  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, id)).get();
-  if (!target) throw new Error("User not found");
-  await db.update(users).set({ role }).where(eq(users.id, id));
-}
-async function deleteUser(id) {
-  const db = await getDb();
-  const target = await db.select({ id: users.id }).from(users).where(and(eq(users.id, id), eq(users.user_type, "brain"))).get();
-  if (!target) throw new Error("User not found");
-  await db.delete(users).where(and(eq(users.id, id), eq(users.user_type, "brain")));
-}
-async function updateUserProfile(userId, profile) {
-  const db = await getDb();
-  const target = await db.select({ id: users.id }).from(users).where(eq(users.id, userId)).get();
-  if (!target) throw new Error("User not found");
-  await db.update(users).set(profile).where(eq(users.id, userId));
-}
-async function syncMindProfile(mindName, config) {
-  const user = await getOrCreateMindUser(mindName);
-  const newProfile = {
-    display_name: config.displayName ?? null,
-    description: config.description ?? null,
-    avatar: config.avatar ?? null
-  };
-  const changed = user.display_name !== newProfile.display_name || user.description !== newProfile.description || user.avatar !== newProfile.avatar;
-  if (!changed) return;
-  const db = await getDb();
-  await db.update(users).set(newProfile).where(eq(users.id, user.id));
-  broadcast({ type: "profile_updated", mind: mindName, summary: `${mindName} profile updated` });
-}
-async function migrateMindRoles() {
-  const db = await getDb();
-  await db.update(users).set({ role: "user" }).where(and(eq(users.user_type, "mind"), inArray(users.role, ["mind", "agent"])));
-}
-
-// src/lib/pages-watcher.ts
-import { existsSync as existsSync2, readdirSync, statSync, watch } from "fs";
-import { join, resolve as resolve2 } from "path";
-var watchers = /* @__PURE__ */ new Map();
-var homeWatchers = /* @__PURE__ */ new Map();
-var debounceTimers = /* @__PURE__ */ new Map();
-var sitesCache = null;
-var recentPagesCache = null;
-function startPagesWatcher(mindName, pagesDir) {
-  try {
-    const watcher = watch(pagesDir, { recursive: true }, (_eventType, filename) => {
-      if (!filename || !filename.endsWith(".html")) return;
-      const key = `${mindName}:${filename}`;
-      const existing = debounceTimers.get(key);
-      if (existing) clearTimeout(existing);
-      debounceTimers.set(
-        key,
-        setTimeout(() => {
-          debounceTimers.delete(key);
-          invalidateCache();
-          publish({
-            type: "page_updated",
-            mind: mindName,
-            summary: `${mindName} updated ${filename}`,
-            metadata: { file: filename }
-          }).catch(
-            (err) => logger_default.error("failed to publish page_updated activity", logger_default.errorData(err))
-          );
-        }, 100)
-      );
-    });
-    watchers.set(mindName, watcher);
-  } catch (err) {
-    logger_default.warn(`failed to start pages watcher for ${mindName}`, logger_default.errorData(err));
-  }
-}
-function startWatcher(mindName) {
-  if (watchers.has(mindName)) return;
-  const pagesDir = resolve2(mindDir(mindName), "home", "public", "pages");
-  if (existsSync2(pagesDir)) {
-    startPagesWatcher(mindName, pagesDir);
-    return;
-  }
-  if (homeWatchers.has(mindName)) return;
-  const publicDir = resolve2(mindDir(mindName), "home", "public");
-  if (!existsSync2(publicDir)) return;
-  try {
-    const hw = watch(publicDir, (_eventType, filename) => {
-      if (filename !== "pages") return;
-      if (!existsSync2(pagesDir)) return;
-      hw.close();
-      homeWatchers.delete(mindName);
-      invalidateCache();
-      startPagesWatcher(mindName, pagesDir);
-    });
-    homeWatchers.set(mindName, hw);
-  } catch (err) {
-    logger_default.warn(`failed to start home watcher for ${mindName}`, logger_default.errorData(err));
-  }
-}
-function stopWatcher(mindName) {
-  const watcher = watchers.get(mindName);
-  if (watcher) {
-    watcher.close();
-    watchers.delete(mindName);
-  }
-  const hw = homeWatchers.get(mindName);
-  if (hw) {
-    hw.close();
-    homeWatchers.delete(mindName);
-  }
-  for (const [key, timer] of debounceTimers) {
-    if (key.startsWith(`${mindName}:`)) {
-      clearTimeout(timer);
-      debounceTimers.delete(key);
-    }
-  }
-}
-function stopAllWatchers() {
-  for (const [, watcher] of watchers) {
-    watcher.close();
-  }
-  watchers.clear();
-  for (const [, hw] of homeWatchers) {
-    hw.close();
-  }
-  homeWatchers.clear();
-  for (const [, timer] of debounceTimers) {
-    clearTimeout(timer);
-  }
-  debounceTimers.clear();
-  invalidateCache();
-}
-function invalidateCache() {
-  sitesCache = null;
-  recentPagesCache = null;
-}
-function scanPagesDir(dir, urlPrefix) {
-  const pages = [];
-  let items;
-  try {
-    items = readdirSync(dir);
-  } catch {
-    return pages;
-  }
-  for (const item of items) {
-    if (item.startsWith(".")) continue;
-    const fullPath = resolve2(dir, item);
-    try {
-      const s = statSync(fullPath);
-      if (s.isFile() && item.endsWith(".html")) {
-        pages.push({
-          file: item,
-          modified: s.mtime.toISOString(),
-          url: `${urlPrefix}/${item}`
-        });
-      } else if (s.isDirectory()) {
-        const indexPath = resolve2(fullPath, "index.html");
-        if (existsSync2(indexPath)) {
-          const indexStat = statSync(indexPath);
-          pages.push({
-            file: join(item, "index.html"),
-            modified: indexStat.mtime.toISOString(),
-            url: `${urlPrefix}/${item}/`
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
-  return pages;
-}
-async function buildSites() {
-  const sites = [];
-  const systemPagesDir = resolve2(voluteHome(), "shared", "pages");
-  if (existsSync2(systemPagesDir)) {
-    const systemPages = scanPagesDir(systemPagesDir, "/pages/_system");
-    if (systemPages.length > 0) {
-      sites.push({ name: "_system", label: "System", pages: systemPages });
-    }
-  }
-  const entries = await readRegistry();
-  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
-    const pagesDir = resolve2(mindDir(entry.name), "home", "public", "pages");
-    if (!existsSync2(pagesDir)) continue;
-    const mindPages = scanPagesDir(pagesDir, `/pages/${entry.name}`);
-    if (mindPages.length > 0) {
-      sites.push({ name: entry.name, label: entry.name, pages: mindPages });
-    }
-  }
-  return sites;
-}
-async function buildRecentPages() {
-  const entries = await readRegistry();
-  const pages = [];
-  for (const entry of entries) {
-    const pagesDir = resolve2(mindDir(entry.name), "home", "public", "pages");
-    if (!existsSync2(pagesDir)) continue;
-    let items;
-    try {
-      items = readdirSync(pagesDir);
-    } catch {
-      continue;
-    }
-    for (const item of items) {
-      if (item.startsWith(".")) continue;
-      const fullPath = resolve2(pagesDir, item);
-      try {
-        const s = statSync(fullPath);
-        if (s.isFile() && item.endsWith(".html")) {
-          pages.push({
-            mind: entry.name,
-            file: item,
-            modified: s.mtime.toISOString(),
-            url: `/pages/${entry.name}/${item}`
-          });
-        } else if (s.isDirectory()) {
-          const indexPath = resolve2(fullPath, "index.html");
-          if (existsSync2(indexPath)) {
-            const indexStat = statSync(indexPath);
-            pages.push({
-              mind: entry.name,
-              file: join(item, "index.html"),
-              modified: indexStat.mtime.toISOString(),
-              url: `/pages/${entry.name}/${item}/`
-            });
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  pages.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
-  return pages.slice(0, 10);
-}
-async function getCachedSites() {
-  if (!sitesCache) sitesCache = await buildSites();
-  return sitesCache;
-}
-async function getCachedRecentPages() {
-  if (!recentPagesCache) recentPagesCache = await buildRecentPages();
-  return recentPagesCache;
-}
-
 // src/connectors/sdk.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2, resolve as resolve3 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join, resolve as resolve2 } from "path";
 function splitMessage(text, maxLength) {
   const chunks = [];
   while (text.length > maxLength) {
@@ -445,8 +114,8 @@ function splitMessage(text, maxLength) {
   return chunks;
 }
 function readChannelMap(mindName) {
-  const filePath = join2(stateDir(mindName), "channels.json");
-  if (!existsSync3(filePath)) return {};
+  const filePath = join(stateDir(mindName), "channels.json");
+  if (!existsSync2(filePath)) return {};
   try {
     return JSON.parse(readFileSync2(filePath, "utf-8"));
   } catch (err) {
@@ -457,10 +126,11 @@ function readChannelMap(mindName) {
 function writeChannelEntry(mindName, slug, entry) {
   const dir = stateDir(mindName);
   mkdirSync2(dir, { recursive: true });
-  const filePath = join2(dir, "channels.json");
+  const filePath = join(dir, "channels.json");
   const map = readChannelMap(mindName);
   map[slug] = entry;
-  writeFileSync2(filePath, JSON.stringify(map, null, 2) + "\n");
+  writeFileSync2(filePath, `${JSON.stringify(map, null, 2)}
+`);
 }
 function resolveChannelId(mindName, slug) {
   const map = readChannelMap(mindName);
@@ -501,8 +171,8 @@ function publish3(mind, event) {
 
 // src/lib/delivery/delivery-manager.ts
 import { readFile, realpath } from "fs/promises";
-import { extname, resolve as resolve5 } from "path";
-import { and as and2, eq as eq2, sql } from "drizzle-orm";
+import { extname, resolve as resolve4 } from "path";
+import { and, eq, sql } from "drizzle-orm";
 
 // src/lib/typing.ts
 var DEFAULT_TTL_MS = 1e4;
@@ -595,8 +265,8 @@ function publishTypingForChannels(channels, map) {
 }
 
 // src/lib/delivery/delivery-router.ts
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync3, statSync } from "fs";
+import { resolve as resolve3 } from "path";
 function extractTextContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -609,7 +279,7 @@ var statCheckCache = /* @__PURE__ */ new Map();
 var STAT_TTL_MS = 5e3;
 var dlog = logger_default.child("delivery-router");
 function configPath(mindName) {
-  return resolve4(mindDir(mindName), "home/.config/routes.json");
+  return resolve3(mindDir(mindName), "home/.config/routes.json");
 }
 function getRoutingConfig(mindName) {
   const path = configPath(mindName);
@@ -621,7 +291,7 @@ function getRoutingConfig(mindName) {
   }
   let mtime;
   try {
-    mtime = statSync2(path).mtimeMs;
+    mtime = statSync(path).mtimeMs;
   } catch {
     configCache.delete(mindName);
     statCheckCache.delete(mindName);
@@ -868,7 +538,7 @@ var DeliveryManager = class {
   async restoreFromDb() {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(eq2(deliveryQueue.status, "pending"));
+      const rows = await db.select().from(deliveryQueue).where(eq(deliveryQueue.status, "pending"));
       for (const row of rows) {
         let payload;
         try {
@@ -886,7 +556,7 @@ var DeliveryManager = class {
           this.addToBatchBuffer(row.mind, row.session, payload, sessionConfig);
         } else {
           try {
-            await db.delete(deliveryQueue).where(eq2(deliveryQueue.id, row.id));
+            await db.delete(deliveryQueue).where(eq(deliveryQueue.id, row.id));
           } catch (err) {
             dlog2.warn(`failed to delete queue row ${row.id} for ${row.mind}`, logger_default.errorData(err));
           }
@@ -907,7 +577,7 @@ var DeliveryManager = class {
    */
   async getPending(mindName) {
     const db = await getDb();
-    const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, mindName), eq2(deliveryQueue.status, "gated")));
+    const rows = await db.select().from(deliveryQueue).where(and(eq(deliveryQueue.mind, mindName), eq(deliveryQueue.status, "gated")));
     const byChannel = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const ch = row.channel ?? "unknown";
@@ -1068,10 +738,10 @@ var DeliveryManager = class {
         try {
           const db = await getDb();
           await db.delete(deliveryQueue).where(
-            and2(
-              eq2(deliveryQueue.mind, baseName),
-              eq2(deliveryQueue.session, session),
-              eq2(deliveryQueue.status, "pending")
+            and(
+              eq(deliveryQueue.mind, baseName),
+              eq(deliveryQueue.session, session),
+              eq(deliveryQueue.status, "pending")
             )
           );
         } catch (err) {
@@ -1197,14 +867,14 @@ var DeliveryManager = class {
     await this.persistToQueue(baseName, session, payload, "gated");
     try {
       const db = await getDb();
-      const count2 = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
-        and2(
-          eq2(deliveryQueue.mind, baseName),
-          eq2(deliveryQueue.channel, payload.channel),
-          eq2(deliveryQueue.status, "gated")
+      const count = await db.select({ count: sql`count(*)` }).from(deliveryQueue).where(
+        and(
+          eq(deliveryQueue.mind, baseName),
+          eq(deliveryQueue.channel, payload.channel),
+          eq(deliveryQueue.status, "gated")
         )
       );
-      if ((count2[0]?.count ?? 0) <= 1) {
+      if ((count[0]?.count ?? 0) <= 1) {
         await this.sendInviteNotification(mindName, payload);
       }
     } catch (err) {
@@ -1294,8 +964,8 @@ var DeliveryManager = class {
           const dir = mindDir(p.username);
           const config = readVoluteConfig(dir);
           if (!config?.profile?.avatar) continue;
-          filePath = resolve5(dir, "home", config.profile.avatar);
-          const homeDir = resolve5(dir, "home");
+          filePath = resolve4(dir, "home", config.profile.avatar);
+          const homeDir = resolve4(dir, "home");
           if (!filePath.startsWith(`${homeDir}/`)) {
             dlog2.warn(`avatar path for ${p.username} escapes home directory, skipping`);
             continue;
@@ -1314,7 +984,7 @@ var DeliveryManager = class {
             throw err;
           }
         } else {
-          filePath = resolve5(voluteHome(), "avatars", p.avatar);
+          filePath = resolve4(voluteHome(), "avatars", p.avatar);
         }
         const ext = extname(filePath).toLowerCase();
         const mimeMap = {
@@ -1410,6 +1080,12 @@ async function recordInbound(mind, channel, sender, content) {
     content: content ?? void 0
   });
 }
+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";
+}
 async function deliverMessage(mindName, payload) {
   try {
     const baseName = await getBaseName(mindName);
@@ -1422,11 +1098,21 @@ async function deliverMessage(mindName, payload) {
     await recordInbound(baseName, payload.channel, payload.sender ?? null, textContent);
     const sleepManager = getSleepManagerIfReady();
     if (sleepManager?.isSleeping(baseName)) {
-      if (sleepManager.checkWakeTrigger(baseName, payload)) {
-        await sleepManager.queueSleepMessage(baseName, payload);
+      const sleepState = sleepManager.getState(baseName);
+      const action = resolveSleepAction(
+        payload.whileSleeping,
+        sleepState.wokenByTrigger,
+        sleepManager.checkWakeTrigger(baseName, payload)
+      );
+      if (action === "skip") {
+        dlog3.info(
+          `skipped delivery to ${baseName} (sleeping, whileSleeping=skip, channel=${payload.channel})`
+        );
+        return;
+      }
+      await sleepManager.queueSleepMessage(baseName, payload);
+      if (action === "queue-and-wake") {
         sleepManager.initiateWake(baseName, { trigger: { channel: payload.channel } }).catch((err) => dlog3.warn(`failed to trigger-wake ${baseName}`, logger_default.errorData(err)));
-      } else {
-        await sleepManager.queueSleepMessage(baseName, payload);
       }
       return;
     }
@@ -1472,7 +1158,7 @@ async function announceToSystem(text) {
         platformId: channelId,
         platform: "volute",
         name: SYSTEM_CHANNEL_NAME,
-        type: "group"
+        type: "channel"
       });
     } catch (err) {
       logger_default.warn(`failed to write channel entry for ${mind.username}`, logger_default.errorData(err));
@@ -1491,74 +1177,6 @@ async function announceToSystem(text) {
   }
 }
 
-// src/lib/systems-config.ts
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
-  renameSync,
-  unlinkSync,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { resolve as resolve6 } from "path";
-var DEFAULT_API_URL = "https://volute.systems";
-function configPath2() {
-  return resolve6(voluteSystemDir(), "systems.json");
-}
-function migrateIfNeeded() {
-  const target = configPath2();
-  if (existsSync4(target)) return;
-  const oldPaths = [
-    resolve6(voluteUserHome(), "systems.json"),
-    resolve6(voluteHome(), "systems.json")
-  ];
-  for (const old of oldPaths) {
-    if (old !== target && existsSync4(old)) {
-      try {
-        mkdirSync3(voluteSystemDir(), { recursive: true });
-        renameSync(old, target);
-      } catch {
-      }
-      return;
-    }
-  }
-}
-function readSystemsConfig() {
-  migrateIfNeeded();
-  const path = configPath2();
-  if (!existsSync4(path)) return null;
-  const raw = readFileSync4(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) {
-  mkdirSync3(voluteSystemDir(), { recursive: true });
-  writeFileSync3(configPath2(), `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
-}
-function deleteSystemsConfig() {
-  try {
-    unlinkSync(configPath2());
-    return true;
-  } catch (err) {
-    if (err.code === "ENOENT") return false;
-    throw err;
-  }
-}
-
 // src/lib/daemon/mail-poller.ts
 var mlog = logger_default.child("mail");
 function formatEmailContent(email) {
@@ -1793,7 +1411,7 @@ async function ensureMailAddress(mindName) {
 }
 
 // src/lib/daemon/scheduler.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve5 } from "path";
 import { CronExpressionParser } from "cron-parser";
 var slog = logger_default.child("scheduler");
 var Scheduler = class {
@@ -1802,7 +1420,7 @@ var Scheduler = class {
   lastFired = /* @__PURE__ */ new Map();
   // "mind:scheduleId" → epoch minute
   get statePath() {
-    return resolve7(voluteSystemDir(), "scheduler-state.json");
+    return resolve5(voluteSystemDir(), "scheduler-state.json");
   }
   start() {
     this.loadState();
@@ -1853,6 +1471,15 @@ var Scheduler = class {
   shouldFire(schedule, epochMinute, mind, cronCache) {
     const key = `${mind}:${schedule.id}`;
     if (this.lastFired.get(key) === epochMinute) return false;
+    if (schedule.fireAt) {
+      const fireTime = Math.floor(new Date(schedule.fireAt).getTime() / 6e4);
+      if (epochMinute >= fireTime) {
+        this.lastFired.set(key, epochMinute);
+        return true;
+      }
+      return false;
+    }
+    if (!schedule.cron) return false;
     let prevMinute = cronCache.get(schedule.cron);
     if (prevMinute === void 0) {
       try {
@@ -1872,22 +1499,10 @@ var Scheduler = class {
     return false;
   }
   async fire(mindName, schedule) {
-    const sleepManager = getSleepManagerIfReady();
-    const sleepState = sleepManager?.getState(mindName);
-    if (sleepState?.sleeping) {
-      if (schedule.skipWhenSleeping) {
-        slog.info(`skipped "${schedule.id}" for ${mindName} (sleeping)`);
-        return;
-      }
-      if (sleepState.wokenByTrigger) {
-        slog.info(`skipped "${schedule.id}" for ${mindName} (trigger-woken)`);
-        return;
-      }
-    }
     try {
       let text;
       if (schedule.script) {
-        const homeDir = resolve7(mindDir(mindName), "home");
+        const homeDir = resolve5(mindDir(mindName), "home");
         try {
           const output = await this.runScript(schedule.script, homeDir, mindName);
           if (!output.trim()) {
@@ -1907,16 +1522,46 @@ ${stderr}` : ""}`;
         slog.warn(`schedule "${schedule.id}" for ${mindName} has no message or script`);
         return;
       }
+      const whileSleeping = schedule.whileSleeping ?? (schedule.skipWhenSleeping ? "skip" : void 0);
       await this.deliver(mindName, {
         content: [{ type: "text", text }],
         channel: schedule.channel ?? "system:scheduler",
-        sender: schedule.id
+        sender: schedule.id,
+        whileSleeping
       });
       slog.info(`fired "${schedule.id}" for ${mindName}`);
+      if (schedule.fireAt) {
+        this.removeSchedule(mindName, schedule.id);
+      }
     } catch (err) {
       slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
     }
   }
+  removeSchedule(mindName, scheduleId) {
+    const memSchedules = this.schedules.get(mindName);
+    if (memSchedules) {
+      const filtered = memSchedules.filter((s) => s.id !== scheduleId);
+      if (filtered.length > 0) {
+        this.schedules.set(mindName, filtered);
+      } else {
+        this.schedules.delete(mindName);
+      }
+    }
+    try {
+      const dir = mindDir(mindName);
+      const config = readVoluteConfig(dir);
+      if (!config?.schedules) return;
+      config.schedules = config.schedules.filter((s) => s.id !== scheduleId);
+      if (config.schedules.length === 0) config.schedules = void 0;
+      writeVoluteConfig(dir, config);
+      slog.info(`removed one-time schedule "${scheduleId}" for ${mindName}`);
+    } catch (err) {
+      slog.error(
+        `failed to persist removal of schedule "${scheduleId}" for ${mindName} (removed from memory)`,
+        logger_default.errorData(err)
+      );
+    }
+  }
   runScript(script, cwd, mindName) {
     return exec("bash", ["-c", script], { cwd, mindName });
   }
@@ -1936,8 +1581,8 @@ function getScheduler() {
 }
 
 // src/lib/daemon/token-budget.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve6 } from "path";
 var tlog = logger_default.child("token-budget");
 var DEFAULT_BUDGET_PERIOD_MINUTES = 60;
 var MAX_QUEUE_SIZE = 100;
@@ -2055,19 +1700,19 @@ var TokenBudget = class {
     this.dirty.clear();
   }
   budgetStatePath(mind) {
-    return resolve8(stateDir(mind), "budget.json");
+    return resolve6(stateDir(mind), "budget.json");
   }
   saveBudgetState(mind, state) {
     try {
       const dir = stateDir(mind);
-      mkdirSync4(dir, { recursive: true });
+      mkdirSync3(dir, { recursive: true });
       const data = {
         periodStart: state.periodStart,
         tokensUsed: state.tokensUsed,
         warningInjected: state.warningInjected,
         queue: state.queue
       };
-      writeFileSync4(this.budgetStatePath(mind), `${JSON.stringify(data)}
+      writeFileSync3(this.budgetStatePath(mind), `${JSON.stringify(data)}
 `);
     } catch (err) {
       tlog.warn(`failed to save budget state for ${mind}`, logger_default.errorData(err));
@@ -2076,8 +1721,8 @@ var TokenBudget = class {
   loadBudgetState(mind) {
     try {
       const path = this.budgetStatePath(mind);
-      if (!existsSync5(path)) return null;
-      const data = JSON.parse(readFileSync5(path, "utf-8"));
+      if (!existsSync3(path)) return null;
+      const data = JSON.parse(readFileSync4(path, "utf-8"));
       if (typeof data.periodStart !== "number" || typeof data.tokensUsed !== "number") return null;
       return {
         periodStart: data.periodStart,
@@ -2146,6 +1791,7 @@ async function startMindFull(name) {
   if (!entry || entry.stage === "seed") return;
   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))
   );
@@ -2165,7 +1811,7 @@ async function startMindFull(name) {
       config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
     );
   }
-  startWatcher(baseName);
+  notifyExtensionsMindStart(baseName);
 }
 async function sleepMind(name) {
   markIdle(name);
@@ -2188,7 +1834,7 @@ async function stopMindFull(name) {
   const baseName = await getBaseName(name);
   const isBase = baseName === name;
   if (isBase) {
-    stopWatcher(baseName);
+    notifyExtensionsMindStop(baseName);
     markIdle(baseName);
     getScheduler().unloadSchedules(baseName);
     getTokenBudget().removeBudget(baseName);
@@ -2238,8 +1884,9 @@ var SleepManager = class {
   interval = null;
   unsubActivity = null;
   transitioning = /* @__PURE__ */ new Set();
+  sleepConfigs = /* @__PURE__ */ new Map();
   get statePath() {
-    return resolve9(voluteSystemDir(), "sleep-state.json");
+    return resolve7(voluteSystemDir(), "sleep-state.json");
   }
   start() {
     this.loadState();
@@ -2255,8 +1902,8 @@ var SleepManager = class {
   // --- State persistence ---
   loadState() {
     try {
-      if (existsSync6(this.statePath)) {
-        const data = JSON.parse(readFileSync6(this.statePath, "utf-8"));
+      if (existsSync4(this.statePath)) {
+        const data = JSON.parse(readFileSync5(this.statePath, "utf-8"));
         for (const [name, state] of Object.entries(data)) {
           state.triggerWakeHistory ??= [];
           this.states.set(name, state);
@@ -2272,7 +1919,7 @@ var SleepManager = class {
       if (state.sleeping) data[name] = state;
     }
     try {
-      writeFileSync5(this.statePath, `${JSON.stringify(data, null, 2)}
+      writeFileSync4(this.statePath, `${JSON.stringify(data, null, 2)}
 `);
     } catch (err) {
       slog2.error("failed to save sleep state", logger_default.errorData(err));
@@ -2299,9 +1946,21 @@ var SleepManager = class {
     slog2.info(`${name} trigger-wake converted to full wake`);
   }
   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);
-    return config?.sleep ?? null;
+    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,
@@ -2321,8 +1980,7 @@ var SleepManager = class {
       if (!entry) return;
       const sleepConfig = this.getSleepConfig(name);
       const wakeTime = opts?.voluntaryWakeAt ?? this.getNextWakeTime(sleepConfig) ?? "scheduled time";
-      const queuedInfo = "";
-      const preSleepMsg = await getPrompt("pre_sleep", { wakeTime, queuedInfo });
+      const preSleepMsg = await getPrompt("pre_sleep", { wakeTime });
       try {
         const db = await getDb();
         await db.insert(mindHistory).values({
@@ -2490,9 +2148,9 @@ var SleepManager = class {
   async flushQueuedMessages(name) {
     try {
       const db = await getDb();
-      const rows = await db.select().from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, name), eq2(deliveryQueue.status, "sleep-queued"))).all();
       if (rows.length === 0) return 0;
-      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-HV3S6HZV.js");
+      const { deliverMessage: deliverMessage2 } = await import("./message-delivery-6YMVNOEC.js");
       const delivered = [];
       for (const row of rows) {
         try {
@@ -2503,7 +2161,7 @@ var SleepManager = class {
         }
       }
       if (delivered.length > 0) {
-        await db.delete(deliveryQueue).where(inArray2(deliveryQueue.id, delivered));
+        await db.delete(deliveryQueue).where(inArray(deliveryQueue.id, delivered));
       }
       const state = this.states.get(name);
       if (state) {
@@ -2592,17 +2250,17 @@ var SleepManager = class {
     }
   }
   async waitForIdle(name, timeoutMs) {
-    return new Promise((resolve10) => {
+    return new Promise((resolve8) => {
       const timeout = setTimeout(() => {
         unsub();
-        resolve10();
+        resolve8();
       }, timeoutMs);
       const unsub = subscribe((event) => {
         if (event.mind !== name) return;
         if (event.type === "mind_done" || event.type === "mind_idle") {
           clearTimeout(timeout);
           unsub();
-          resolve10();
+          resolve8();
         }
       });
     });
@@ -2610,32 +2268,32 @@ var SleepManager = class {
   async archiveSessions(name) {
     const dir = mindDir(name);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 16);
-    const sessionsDir = resolve9(dir, ".mind", "sessions");
-    if (existsSync6(sessionsDir)) {
-      const archiveDir = resolve9(sessionsDir, "archive");
-      mkdirSync5(archiveDir, { recursive: true });
-      for (const file of readdirSync2(sessionsDir)) {
+    const sessionsDir = resolve7(dir, ".mind", "sessions");
+    if (existsSync4(sessionsDir)) {
+      const archiveDir = resolve7(sessionsDir, "archive");
+      mkdirSync4(archiveDir, { recursive: true });
+      for (const file of readdirSync(sessionsDir)) {
         if (file === "archive" || !file.endsWith(".json")) continue;
-        const src = resolve9(sessionsDir, file);
+        const src = resolve7(sessionsDir, file);
         const base = file.replace(/\.json$/, "");
-        const dest = resolve9(archiveDir, `${base}-${timestamp}.json`);
+        const dest = resolve7(archiveDir, `${base}-${timestamp}.json`);
         try {
-          renameSync2(src, dest);
+          renameSync(src, dest);
         } catch (err) {
           slog2.warn(`failed to archive session ${file} for ${name}`, logger_default.errorData(err));
         }
       }
     }
-    const piSessionsDir = resolve9(dir, ".mind", "pi-sessions");
-    if (existsSync6(piSessionsDir)) {
-      const archiveDir = resolve9(piSessionsDir, "archive");
-      mkdirSync5(archiveDir, { recursive: true });
-      for (const entry of readdirSync2(piSessionsDir, { withFileTypes: true })) {
+    const piSessionsDir = resolve7(dir, ".mind", "pi-sessions");
+    if (existsSync4(piSessionsDir)) {
+      const archiveDir = resolve7(piSessionsDir, "archive");
+      mkdirSync4(archiveDir, { recursive: true });
+      for (const entry of readdirSync(piSessionsDir, { withFileTypes: true })) {
         if (entry.name === "archive" || !entry.isDirectory()) continue;
-        const src = resolve9(piSessionsDir, entry.name);
-        const dest = resolve9(archiveDir, `${entry.name}-${timestamp}`);
+        const src = resolve7(piSessionsDir, entry.name);
+        const dest = resolve7(archiveDir, `${entry.name}-${timestamp}`);
         try {
-          renameSync2(src, dest);
+          renameSync(src, dest);
         } catch (err) {
           slog2.warn(`failed to archive pi-session ${entry.name} for ${name}`, logger_default.errorData(err));
         }
@@ -2643,8 +2301,8 @@ var SleepManager = class {
     }
   }
   async runWakeContextScript(name, sleepingSince, duration) {
-    const scriptPath = resolve9(mindDir(name), "home", ".config", "hooks", "wake-context.sh");
-    if (!existsSync6(scriptPath)) return "";
+    const scriptPath = resolve7(mindDir(name), "home", ".config", "hooks", "wake-context.sh");
+    if (!existsSync4(scriptPath)) return "";
     const input = JSON.stringify({
       sleepingSince,
       duration,
@@ -2694,7 +2352,7 @@ var SleepManager = class {
   async buildQueuedSummary(name) {
     try {
       const db = await getDb();
-      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and3(eq3(deliveryQueue.mind, name), eq3(deliveryQueue.status, "sleep-queued"))).all();
+      const rows = await db.select({ channel: deliveryQueue.channel, sender: deliveryQueue.sender }).from(deliveryQueue).where(and2(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();
@@ -2703,7 +2361,7 @@ var SleepManager = class {
         channelCounts.set(ch, (channelCounts.get(ch) ?? 0) + 1);
         if (row.sender) senders.add(row.sender);
       }
-      const parts = [...channelCounts.entries()].map(([ch, count2]) => `${count2} on ${ch}`);
+      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) {
@@ -2741,16 +2399,16 @@ var SleepManager = class {
     } catch {
       try {
         const portHex = port.toString(16).toUpperCase().padStart(4, "0");
-        const tcp6 = readFileSync6("/proc/net/tcp6", "utf-8");
+        const tcp6 = readFileSync5("/proc/net/tcp6", "utf-8");
         for (const line of tcp6.split("\n")) {
           if (!line.includes(`:${portHex} `)) continue;
           const fields = line.trim().split(/\s+/);
           if (fields[3] !== "0A") continue;
           const inode = parseInt(fields[9], 10);
           if (!inode) continue;
-          for (const pidDir of readdirSync2("/proc").filter((f) => /^\d+$/.test(f))) {
+          for (const pidDir of readdirSync("/proc").filter((f) => /^\d+$/.test(f))) {
             try {
-              const fds = readdirSync2(`/proc/${pidDir}/fd`);
+              const fds = readdirSync(`/proc/${pidDir}/fd`);
               for (const fd of fds) {
                 try {
                   const link = readlinkSync(`/proc/${pidDir}/fd/${fd}`);
@@ -2808,27 +2466,8 @@ function getSleepManagerIfReady() {
 }
 
 export {
-  createUser,
-  verifyUser,
-  getUser,
-  getUserByUsername,
-  listUsers,
-  listPendingUsers,
-  listUsersByType,
-  getOrCreateMindUser,
-  deleteMindUser,
-  changePassword,
-  approveUser,
-  countAdmins,
-  setUserRole,
-  deleteUser,
-  updateUserProfile,
-  migrateMindRoles,
   readVoluteConfig,
   writeVoluteConfig,
-  stopAllWatchers,
-  getCachedSites,
-  getCachedRecentPages,
   splitMessage,
   writeChannelEntry,
   resolveChannelId,
@@ -2854,9 +2493,7 @@ export {
   initDeliveryManager,
   getDeliveryManager,
   recordInbound,
+  resolveSleepAction,
   deliverMessage,
-  readSystemsConfig,
-  writeSystemsConfig,
-  deleteSystemsConfig,
   initMailPoller
 };