volute 0.49.0 → 0.51.0

package/dist/{chunk-BCG45AQB.js → chunk-M74I3HHF.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  detectSystemInstallHint
+} from "./chunk-FNJCBRD3.js";
 
 // packages/cli/src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";
@@ -40,12 +43,19 @@ function readCliSession() {
   }
 }
 function readDaemonConfig() {
+  const mindPort = process.env.VOLUTE_MIND_TOKEN && process.env.VOLUTE_DAEMON_PORT;
+  if (mindPort) {
+    return {
+      port: Number(mindPort),
+      hostname: process.env.VOLUTE_DAEMON_HOSTNAME || "127.0.0.1",
+      token: process.env.VOLUTE_MIND_TOKEN
+    };
+  }
   const configPath = resolve(voluteSystemDir(), "daemon.json");
   if (!existsSync(configPath)) {
-    if (existsSync("/etc/systemd/system/volute.service") && !process.env.VOLUTE_HOME) {
-      console.error("Volute is running as a system service but VOLUTE_HOME is not set.");
-      console.error("Re-run setup to update the CLI wrapper: sudo volute service install --system");
-      console.error("Then start a new shell or run: source /etc/profile.d/volute.sh");
+    const hint = detectSystemInstallHint();
+    if (hint) {
+      console.error(hint);
     } else {
       console.error("Volute is not running. Start with: volute up");
     }
@@ -111,7 +121,7 @@ async function daemonFetch(path, options) {
   headers.set("Origin", url);
   const voluteSession = process.env.VOLUTE_SESSION ?? readMindSessionFile();
   if (voluteSession) {
-    headers.set("X-Volute-Session", voluteSession);
+    headers.set("X-Volute-Thread", voluteSession);
   }
   try {
     const res = await fetch(`${url}${path}`, {

package/dist/{chunk-DVN6DNMI.js → chunk-M77B73VV.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   getBaseName,
+  isSpiritName,
   validateMindName
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/mind/isolation.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -63,7 +64,7 @@ function isIsolationEnabled() {
 }
 function mindUserName(mindName) {
   const err = validateMindName(mindName);
-  if (err && mindName !== "volute") {
+  if (err && !isSpiritName(mindName)) {
     throw new Error(`Invalid mind name for isolation: ${err}`);
   }
   const prefix = process.env.VOLUTE_USER_PREFIX ?? "mind-";
@@ -255,6 +256,19 @@ async function chownMindDir(dir, name) {
     throw new Error(`Failed to chmod ${dir}${stderr ? `: ${stderr}` : ""}`);
   }
 }
+async function chownMindFile(filePath, name) {
+  if (!isIsolationEnabled()) return;
+  const user = mindUserName(name);
+  const group = process.platform === "darwin" ? "volute" : user;
+  try {
+    await exec("chown", [`${user}:${group}`, filePath]);
+  } catch (err) {
+    const stderr = String(err?.stderr ?? "").trim();
+    throw new Error(
+      `Failed to chown ${filePath} to ${user}:${group}${stderr ? `: ${stderr}` : ""}`
+    );
+  }
+}
 
 export {
   isIsolationEnabled,
@@ -265,6 +279,7 @@ export {
   wrapForIsolation,
   chownTargets,
   chownMindDir,
+  chownMindFile,
   exec,
   gitExec,
   resolveVoluteBin,

package/dist/{chunk-4B62E4CG.js → chunk-OXWUEU5V.js}

@@ -3,10 +3,10 @@ import {
   LAUNCHD_PLIST_LABEL,
   LAUNCHD_PLIST_PATH,
   USER_SYSTEMD_UNIT
-} from "./chunk-HCYQRME2.js";
+} from "./chunk-6NLW72HP.js";
 import {
   resolveVoluteBin
-} from "./chunk-DVN6DNMI.js";
+} from "./chunk-M77B73VV.js";
 
 // packages/daemon/src/lib/config/service-install.ts
 import { execFile } from "child_process";

package/dist/chunk-Q7XQLKZB.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import {
+  buildMindBaseEnv,
+  clearJsonMap,
+  generateMindToken,
+  getMindToken,
+  loadJsonMap,
+  saveJsonMapAsync
+} from "./chunk-VAEZCIJC.js";
+import {
+  deliverEvent
+} from "./chunk-ICL6T4SN.js";
+import {
+  isSandboxEnabled,
+  wrapForSandbox
+} from "./chunk-5Y54AE3L.js";
+import {
+  readVoluteConfig,
+  writeVoluteConfig
+} from "./chunk-WCFSBH33.js";
+import {
+  exec
+} from "./chunk-M77B73VV.js";
+import {
+  loadMergedEnv
+} from "./chunk-GLM7TVWP.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  mindDir,
+  mindTmpDir,
+  mindTmpEnv,
+  stateDir,
+  voluteSystemDir
+} from "./chunk-H6X6CKDN.js";
+
+// packages/daemon/src/lib/daemon/scheduler.ts
+import { resolve } from "path";
+import { CronExpressionParser } from "cron-parser";
+var slog = logger_default.child("scheduler");
+var CATCHUP_STALE_MINUTES = 10;
+var Scheduler = class {
+  schedules = /* @__PURE__ */ new Map();
+  mindDirs = /* @__PURE__ */ new Map();
+  // mindName → dir override
+  interval = null;
+  lastFired = /* @__PURE__ */ new Map();
+  // "mind:scheduleId" → epoch minute
+  get statePath() {
+    return resolve(voluteSystemDir(), "scheduler-state.json");
+  }
+  start() {
+    this.loadState();
+    this.interval = setInterval(() => {
+      this.tick().catch((err) => slog.error("scheduler tick failed", logger_default.errorData(err)));
+    }, 6e4);
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+  }
+  loadState() {
+    this.lastFired = loadJsonMap(this.statePath);
+  }
+  async saveState() {
+    await saveJsonMapAsync(this.statePath, this.lastFired);
+  }
+  clearState() {
+    clearJsonMap(this.statePath, this.lastFired);
+  }
+  loadSchedules(mindName, dir) {
+    if (dir) this.mindDirs.set(mindName, dir);
+    const resolvedDir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+    const config = readVoluteConfig(resolvedDir);
+    if (!config) return;
+    const schedules = config.schedules ?? [];
+    if (schedules.length > 0) {
+      this.schedules.set(mindName, schedules);
+    } else {
+      this.schedules.delete(mindName);
+    }
+    const epochMinute = Math.floor(Date.now() / 6e4);
+    const validKeys = new Set(schedules.map((s) => `${mindName}:${s.id}`));
+    let changed = false;
+    for (const key of this.lastFired.keys()) {
+      if (key.startsWith(`${mindName}:`) && !validKeys.has(key)) {
+        this.lastFired.delete(key);
+        changed = true;
+      }
+    }
+    for (const key of validKeys) {
+      if (!this.lastFired.has(key)) {
+        this.lastFired.set(key, epochMinute);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.saveState().catch(
+        (err) => slog.warn(`failed to persist scheduler state for ${mindName}`, logger_default.errorData(err))
+      );
+    }
+  }
+  unloadSchedules(mindName) {
+    this.schedules.delete(mindName);
+    this.mindDirs.delete(mindName);
+  }
+  async tick() {
+    const now = /* @__PURE__ */ new Date();
+    const epochMinute = Math.floor(now.getTime() / 6e4);
+    const cronCache = /* @__PURE__ */ new Map();
+    let anyFired = false;
+    for (const [mind, schedules] of this.schedules) {
+      for (const schedule of schedules) {
+        if (!schedule.enabled) continue;
+        if (this.shouldFire(schedule, epochMinute, mind, cronCache)) {
+          anyFired = true;
+          this.fire(mind, schedule);
+        }
+      }
+    }
+    if (anyFired) await this.saveState();
+  }
+  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 {
+        const interval = CronExpressionParser.parse(schedule.cron);
+        const prev = interval.prev().toDate();
+        prevMinute = Math.floor(prev.getTime() / 6e4);
+        cronCache.set(schedule.cron, prevMinute);
+      } catch (err) {
+        slog.warn(`invalid cron "${schedule.cron}" for ${mind}:${schedule.id}`, logger_default.errorData(err));
+        return false;
+      }
+    }
+    const lastFired = this.lastFired.get(key) ?? epochMinute;
+    if (prevMinute <= lastFired) return false;
+    this.lastFired.set(key, prevMinute);
+    if (epochMinute - prevMinute > CATCHUP_STALE_MINUTES) {
+      slog.info(`skipping stale catch-up fire for ${key} (${epochMinute - prevMinute}min late)`);
+      return false;
+    }
+    return true;
+  }
+  async fire(mindName, schedule) {
+    try {
+      let text;
+      if (schedule.script) {
+        const homeDir = resolve(this.mindDirs.get(mindName) ?? mindDir(mindName), "home");
+        try {
+          const output = await this.runScript(schedule.script, homeDir, mindName);
+          if (!output.trim()) {
+            slog.info(`fired script "${schedule.id}" for ${mindName} (no output)`);
+            return;
+          }
+          text = output;
+        } catch (err) {
+          const stderr = err.stderr ?? "";
+          text = `[script error] ${err.message}${stderr ? `
+${stderr}` : ""}`;
+          slog.warn(`script "${schedule.id}" failed for ${mindName}`, logger_default.errorData(err));
+        }
+      } else if (Array.isArray(schedule.messages) && schedule.messages.length > 0) {
+        const pick = schedule.messages[Math.floor(Math.random() * schedule.messages.length)];
+        if (typeof pick !== "string" || !pick.trim()) {
+          slog.warn(`schedule "${schedule.id}" for ${mindName} has a malformed messages pool`);
+          return;
+        }
+        text = pick;
+      } else if (schedule.message) {
+        text = schedule.message;
+      } else {
+        slog.warn(`schedule "${schedule.id}" for ${mindName} has no message, messages, or script`);
+        return;
+      }
+      const { id, delivered } = await this.deliverSystem(mindName, schedule.id, text, {
+        // Default schedule fires to "queue" while asleep so an unadorned cron
+        // schedule doesn't inherit the DM wake-trigger fallback and wake the mind.
+        whileSleeping: schedule.whileSleeping ?? "queue",
+        thread: schedule.thread
+      });
+      slog.info(`fired "${schedule.id}" for ${mindName}${delivered ? "" : " (event pending)"}`);
+      if (schedule.fireAt && id != null) {
+        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 = this.mindDirs.get(mindName) ?? 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)
+      );
+    }
+  }
+  async runScript(script, cwd, mindName) {
+    const env = await this.buildScriptEnv(mindName);
+    if (isSandboxEnabled()) {
+      const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+      const [cmd, args] = await wrapForSandbox("bash", ["-c", script], dir, mindName, [
+        dir,
+        mindTmpDir(dir)
+      ]);
+      return exec(cmd, args, { cwd, env });
+    }
+    return exec("bash", ["-c", script], { cwd, mindName, env });
+  }
+  /**
+   * Build the environment for a scheduled script — mirrors the mind process env
+   * (allowlisted base + merged mind env + VOLUTE_* runtime vars), authenticated
+   * with the mind's own per-mind, non-admin token. Reuses the running mind's
+   * token when present; otherwise mints one (stable across fires, regenerated on
+   * next mind start). The daemon admin token is never included.
+   */
+  async buildScriptEnv(mindName) {
+    const dir = this.mindDirs.get(mindName) ?? mindDir(mindName);
+    const entry = await findMind(mindName);
+    const token = getMindToken(mindName) ?? generateMindToken(mindName);
+    const mindLocalBin = resolve(dir, "home", ".local", "bin");
+    const currentPath = process.env.PATH ?? "";
+    return {
+      ...buildMindBaseEnv(),
+      ...loadMergedEnv(mindName),
+      VOLUTE_MIND: mindName,
+      VOLUTE_STATE_DIR: stateDir(mindName),
+      VOLUTE_MIND_DIR: dir,
+      VOLUTE_MIND_PORT: entry ? String(entry.port) : void 0,
+      VOLUTE_MIND_TOKEN: token,
+      ...mindTmpEnv(dir),
+      PATH: `${mindLocalBin}:${currentPath}`
+    };
+  }
+  async deliverSystem(mindName, scheduleId, text, opts) {
+    return deliverEvent(mindName, {
+      type: "schedule",
+      body: text,
+      meta: { scheduleId },
+      thread: opts?.thread,
+      whileSleeping: opts?.whileSleeping
+    });
+  }
+};
+var instance = null;
+function initScheduler() {
+  if (instance) throw new Error("Scheduler already initialized");
+  instance = new Scheduler();
+  return instance;
+}
+function getScheduler() {
+  if (!instance) throw new Error("Scheduler not initialized \u2014 call initScheduler() first");
+  return instance;
+}
+
+export {
+  Scheduler,
+  initScheduler,
+  getScheduler
+};

package/dist/{chunk-GWVFDUNB.js → chunk-QT4D5XCI.js}

@@ -2,23 +2,21 @@
 import {
   exec,
   gitExec
-} from "./chunk-DVN6DNMI.js";
-import {
-  readGlobalConfig,
-  writeGlobalConfig
-} from "./chunk-NJHN6IRB.js";
+} from "./chunk-M77B73VV.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
 import {
   getDb,
   mindDir,
+  readGlobalConfig,
   readRegistry,
-  voluteHome
-} from "./chunk-RSBL3FAD.js";
+  voluteHome,
+  writeGlobalConfig
+} from "./chunk-H6X6CKDN.js";
 import {
   sharedSkills
-} from "./chunk-P4LHVRNE.js";
+} from "./chunk-2RNMBXD2.js";
 
 // packages/daemon/src/lib/skills.ts
 import { createHash } from "crypto";
@@ -47,7 +45,7 @@ async function initDefaultSkills() {
   const config = readGlobalConfig();
   let extensionSkills = [];
   try {
-    const { getExtensionStandardSkills } = await import("./extensions-AWNO3SZF.js");
+    const { getExtensionStandardSkills } = await import("./extensions-NY6WST33.js");
     extensionSkills = getExtensionStandardSkills();
   } catch (err) {
     logger_default.warn("failed to load extension standard skills during init", logger_default.errorData(err));
@@ -639,7 +637,7 @@ async function syncBuiltinSkills() {
       const destDir = join(sharedSkillsDir(), entry.name);
       if (existsSync(destDir)) {
         const destHash = hashSkillDir(destDir);
-        if (sourceHash === destHash) continue;
+        if (sourceHash === destHash && await getSharedSkill(entry.name)) continue;
       }
       await importSkillFromDir(sourceDir, "volute");
       logger_default.info(`synced built-in skill: ${entry.name}`);

package/dist/{chunk-VNRSXEBF.js → chunk-TPX6E6PL.js}

@@ -2,13 +2,13 @@
 import {
   bufferEvent,
   subscribe
-} from "./chunk-3B427GUK.js";
+} from "./chunk-U54PJPTB.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
 import {
   getDb
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 import {
   channels,
   conversationParticipants,
@@ -16,7 +16,7 @@ import {
   conversations,
   messages,
   users
-} from "./chunk-P4LHVRNE.js";
+} from "./chunk-2RNMBXD2.js";
 
 // packages/daemon/src/lib/events/conversations.ts
 import { randomUUID } from "crypto";
@@ -99,6 +99,21 @@ function subscribe2(conversationId, callback) {
     if (set.size === 0) subscribers.delete(conversationId);
   };
 }
+var participantSubscribers = /* @__PURE__ */ new Set();
+function subscribeParticipantAdded(callback) {
+  participantSubscribers.add(callback);
+  return () => participantSubscribers.delete(callback);
+}
+function publishParticipantAdded(conversationId, userId) {
+  for (const cb of participantSubscribers) {
+    try {
+      cb({ conversationId, userId });
+    } catch (err) {
+      console.error("[conversation-events] participant subscriber threw:", err);
+      participantSubscribers.delete(cb);
+    }
+  }
+}
 function publish(conversationId, event) {
   const set = subscribers.get(conversationId);
   if (!set) return;
@@ -134,6 +149,9 @@ async function createConversation(opts) {
         role: i === 0 ? "owner" : "member"
       }))
     );
+    for (const uid of opts.participantIds) {
+      publishParticipantAdded(id, uid);
+    }
   }
   fireWebhook({
     event: "conversation_created",
@@ -161,6 +179,7 @@ async function addParticipant(conversationId, userId, role = "member") {
     user_id: userId,
     role
   });
+  publishParticipantAdded(conversationId, userId);
 }
 async function removeParticipant(conversationId, userId) {
   const db = await getDb();
@@ -251,6 +270,11 @@ async function addMessage(conversationId, role, senderName, content, opts) {
   });
   return msg;
 }
+async function getLastMessageBySender(conversationId, sender) {
+  const db = await getDb();
+  const row = await db.select().from(messages).where(and(eq(messages.conversation_id, conversationId), eq(messages.sender_name, sender))).orderBy(desc(messages.id)).limit(1).get();
+  return row ? parseMessageRow(row) : null;
+}
 async function getMessages(conversationId, limit = 200) {
   const db = await getDb();
   const rows = await db.select().from(messages).where(eq(messages.conversation_id, conversationId)).orderBy(desc(messages.id)).limit(limit).all();
@@ -351,6 +375,12 @@ async function listConversationsWithParticipants(userId) {
   const convs = await listConversationsForUser(userId);
   return enrichConversations(convs);
 }
+async function getConversationWithParticipants(conversationId) {
+  const conv = await getConversation(conversationId);
+  if (!conv) return null;
+  const [enriched] = await enrichConversations([conv]);
+  return enriched ?? null;
+}
 async function findDMConversation(participantIds) {
   const db = await getDb();
   const [id1, id2] = participantIds;
@@ -513,12 +543,13 @@ async function markConversationRead(userId, conversationId) {
 }
 
 export {
+  subscribe2 as subscribe,
+  subscribeParticipantAdded,
+  publish,
   getWebhookUrl,
   getAuthHeaders,
   fireWebhook,
   initWebhook,
-  subscribe2 as subscribe,
-  publish,
   createConversation,
   getConversation,
   addParticipant,
@@ -529,9 +560,11 @@ export {
   isParticipantOrOwner,
   deleteConversationForUser,
   addMessage,
+  getLastMessageBySender,
   getMessages,
   getMessagesPaginated,
   listConversationsWithParticipants,
+  getConversationWithParticipants,
   findDMConversation,
   listConversationsForMind,
   isConversationForMind,

package/dist/{chunk-3B427GUK.js → chunk-U54PJPTB.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-QUSMYGNQ.js";
 import {
   getDb
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 import {
   activity
-} from "./chunk-P4LHVRNE.js";
+} from "./chunk-2RNMBXD2.js";
 
 // packages/daemon/src/lib/events/event-sequencer.ts
 var BUFFER_SIZE = 1e3;

package/dist/{chunk-EFT2OALG.js → chunk-UDZLPR34.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-QUSMYGNQ.js";
 import {
   mindDir
-} from "./chunk-RSBL3FAD.js";
+} from "./chunk-H6X6CKDN.js";
 
 // packages/daemon/src/lib/delivery/delivery-router.ts
 import { readFileSync, statSync } from "fs";
@@ -63,6 +63,7 @@ function getRoutingConfig(mindName) {
   try {
     const config = JSON.parse(readFileSync(path, "utf-8"));
     const changed = cached != null && cached.mtime !== mtime;
+    warnUnknownRuleKeys(mindName, config);
     configCache.set(mindName, { config, mtime });
     if (changed) notifyRoutesChanged(mindName);
     return config;
@@ -94,7 +95,20 @@ function globMatch(pattern, value) {
   return regex.test(value);
 }
 var GLOB_MATCH_KEYS = /* @__PURE__ */ new Set(["channel", "sender"]);
-var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["session", "destination", "path", "mode", "batch"]);
+var NON_MATCH_KEYS = /* @__PURE__ */ new Set(["thread", "destination", "path", "mode", "batch"]);
+var KNOWN_RULE_KEYS = /* @__PURE__ */ new Set([...GLOB_MATCH_KEYS, ...NON_MATCH_KEYS, "isDM", "participants"]);
+function warnUnknownRuleKeys(mindName, config) {
+  if (!Array.isArray(config.rules)) return;
+  for (const rule of config.rules) {
+    if (rule == null || typeof rule !== "object") continue;
+    const unknown = Object.keys(rule).filter((k) => !KNOWN_RULE_KEYS.has(k));
+    if (unknown.length > 0) {
+      dlog.warn(
+        `routes.json for ${mindName} has a rule with unrecognized key(s) ${unknown.map((k) => `"${k}"`).join(", ")} \u2014 the rule will never match (known keys: ${[...KNOWN_RULE_KEYS].join(", ")})`
+      );
+    }
+  }
+}
 function ruleMatches(rule, meta) {
   for (const [key, pattern] of Object.entries(rule)) {
     if (NON_MATCH_KEYS.has(key)) continue;
@@ -137,7 +151,7 @@ function resolveRoute(config, meta) {
       }
       return {
         destination: "mind",
-        session: sanitizeSessionName(expandTemplate(rule.session ?? fallback, meta)),
+        session: sanitizeSessionName(expandTemplate(rule.thread ?? fallback, meta)),
         matched: true,
         mode: rule.mode,
         rule
@@ -160,7 +174,7 @@ function resolveDeliveryMode(config, sessionName, rule) {
   const defaults = {
     delivery: { mode: "immediate" }
   };
-  if (!config.sessions) {
+  if (!config.threads) {
     if (ruleBatch != null) {
       const batch = normalizeBatchConfig(ruleBatch);
       return {
@@ -174,7 +188,7 @@ function resolveDeliveryMode(config, sessionName, rule) {
     }
     return defaults;
   }
-  for (const [pattern, sessionConfig] of Object.entries(config.sessions)) {
+  for (const [pattern, sessionConfig] of Object.entries(config.threads)) {
     if (globMatch(pattern, sessionName)) {
       let delivery;
       if (sessionConfig.delivery == null || sessionConfig.delivery === "immediate") {
@@ -219,6 +233,7 @@ export {
   registerMindDir,
   getRoutingConfig,
   clearConfigCache,
+  warnUnknownRuleKeys,
   resolveRoute,
   shouldGate,
   resolveDeliveryMode

package/dist/{chunk-ZX46PGCC.js → chunk-UFTDRTCP.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   publish
-} from "./chunk-3B427GUK.js";
+} from "./chunk-U54PJPTB.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";