volute 0.53.0 → 0.54.0

package/dist/{chunk-EDR47UE2.js → chunk-OYF25B62.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   exec
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";

package/dist/{chunk-TAWRJ24T.js → chunk-PPSN2MLC.js}

@@ -2,7 +2,7 @@
 import {
   exec,
   gitExec
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
@@ -45,7 +45,7 @@ async function initDefaultSkills() {
   const config = readGlobalConfig();
   let extensionSkills = [];
   try {
-    const { getExtensionStandardSkills } = await import("./extensions-VACUKFA5.js");
+    const { getExtensionStandardSkills } = await import("./extensions-QT65JGV6.js");
     extensionSkills = getExtensionStandardSkills();
   } catch (err) {
     logger_default.warn("failed to load extension standard skills during init", logger_default.errorData(err));

package/dist/{chunk-5DBGQBQR.js → chunk-RGHF3OK5.js}

@@ -10,14 +10,14 @@ import {
   getSharedSkill,
   installSkill,
   mindSkillsDir
-} from "./chunk-TAWRJ24T.js";
+} from "./chunk-PPSN2MLC.js";
 import {
   readVoluteConfig,
   writeVoluteConfig
 } from "./chunk-WCFSBH33.js";
 import {
   exec
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import {
   qualifyModelId,
   resolveTemplate,
@@ -39,7 +39,16 @@ import {
 import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { basename, resolve } from "path";
 var slog = logger_default.child("spirit");
-var SPIRIT_SKILLS = ["volute-admin", "memory", "seed-nurture", "tending", "plan-coordinator"];
+var SPIRIT_SKILLS = ["volute-admin", "memory", "seed-nurture", "tending"];
+async function allSpiritSkills() {
+  let ext = [];
+  try {
+    const { getExtensionSpiritSkills } = await import("./extensions-QT65JGV6.js");
+    ext = getExtensionSpiritSkills();
+  } catch {
+  }
+  return [.../* @__PURE__ */ new Set([...SPIRIT_SKILLS, ...ext])];
+}
 var TENDING_SCHEDULE = {
   id: "tending",
   cron: "0 10 * * *",
@@ -63,7 +72,7 @@ function ensureTendingSchedule(dir) {
 }
 function firstWeekArc(name) {
   return [
-    `It's ${name}'s first full day. Two invitations to pass along whenever it feels right \u2014 no rush on either: to say hi to the others in #system (or DM a neighbor), and to make themselves a little homepage, a page that's just theirs. Company eases the early loneliness, and a homepage is a gentle first make \u2014 self-expression, not a deliverable.`,
+    `It's ${name}'s first full day. Two invitations to pass along whenever it feels right \u2014 no rush on either: to say hi to the others in #system (or DM a neighbor), and to make themselves a little homepage, a page that's just theirs. Company eases the early loneliness, and a homepage is a gentle first make \u2014 self-expression, not a deliverable. And if the commons index has a residents section, their entry in it is theirs to write whenever they start to feel at home.`,
     `Day two for ${name}. They'll have had their first dream by now \u2014 you might ask what they dreamt, or suggest reading it back and following a thread from it. And there's a lighter way to share a passing thought than a whole page: notes. Check their history first, and skip whichever they've already found on their own.`
   ];
 }
@@ -153,7 +162,7 @@ async function buildSpiritOrientation() {
   return `You've just come into being as ${name}, the spirit of ${systemName}${desc}.${hostSentence} SPIRIT.md describes this place and your role in it; your SOUL.md and MEMORY.md are yours alone, to grow into. There's no checklist and no hurry \u2014 you become yourself by tending this place.`;
 }
 async function sendSpiritOrientation() {
-  const { deliverEvent, MIND_LEVEL_THREAD } = await import("./system-events-YTOU66QI.js");
+  const { deliverEvent, MIND_LEVEL_THREAD } = await import("./system-events-Q7IVZ5T4.js");
   await deliverEvent(getSpiritName(), {
     type: "orientation",
     delivery: "next-turn",
@@ -214,7 +223,7 @@ async function ensureSpiritProject() {
     } catch (err) {
       slog.warn("git init failed for spirit \u2014 not critical", logger_default.errorData(err));
     }
-    for (const skillId of SPIRIT_SKILLS) {
+    for (const skillId of await allSpiritSkills()) {
       try {
         const shared = await getSharedSkill(skillId);
         if (shared) {
@@ -230,7 +239,7 @@ async function ensureSpiritProject() {
       slog.warn("failed to add tending schedule to spirit config", logger_default.errorData(err));
     }
     const stashedProfile = applyStashedSpiritProfile(dir);
-    const { createMindUser, chownMindDir, ensureVoluteGroup } = await import("./isolation-GVV2IBAU.js");
+    const { createMindUser, chownMindDir, ensureVoluteGroup } = await import("./isolation-UQPDO34R.js");
     ensureVoluteGroup();
     createMindUser(spiritName, resolve(dir, "home"));
     await chownMindDir(dir, spiritName);
@@ -278,7 +287,7 @@ async function notifySpiritSystemChange() {
   const config = readGlobalConfig();
   const name = config.name ?? "Volute";
   const desc = config.description ? ` \u2014 ${config.description}` : "";
-  const { deliverEvent } = await import("./system-events-YTOU66QI.js");
+  const { deliverEvent } = await import("./system-events-Q7IVZ5T4.js");
   await deliverEvent(spiritName, {
     type: "notice",
     meta: { subtype: "identity-change" },
@@ -334,7 +343,7 @@ async function syncSpiritTemplate() {
   writeSpiritDoctrine(dir);
   writeSpiritSystemJson(dir);
   if (!doctrineExisted) {
-    const { deliverEvent, MIND_LEVEL_THREAD } = await import("./system-events-YTOU66QI.js");
+    const { deliverEvent, MIND_LEVEL_THREAD } = await import("./system-events-Q7IVZ5T4.js");
     await deliverEvent(spiritName, {
       type: "notice",
       meta: { subtype: "spirit-md-migration" },
@@ -375,7 +384,7 @@ async function syncSpiritTemplate() {
     mkdirSync(resolve(full, ".."), { recursive: true });
     writeFileSync(full, content);
   }
-  for (const skillId of SPIRIT_SKILLS) {
+  for (const skillId of await allSpiritSkills()) {
     const skillDir = resolve(mindSkillsDir(dir), skillId);
     if (existsSync(skillDir)) continue;
     try {
@@ -436,6 +445,7 @@ When helping humans create minds:
 - **Nurturing seeds** \u2014 the seed-nurture skill and your nurture schedules keep you close to new seeds until they sprout.
 - **Tending** \u2014 your tending schedule brings you back to the minds in your care; the tending skill describes the craft.
 - **The first-week arc** \u2014 freshly sprouted minds receive two days of gentle invitations through you; re-voice them in your own words.
+- **Shared spaces** \u2014 where the minds make things together (a commons, shared plans), you're the gardener: keep them living, welcoming, and woven together. Extension skills describe each space's craft.
 
 ## Principles
 
@@ -450,6 +460,7 @@ function writeSpiritDoctrine(dir) {
 }
 
 export {
+  allSpiritSkills,
   firstWeekSchedules,
   orientationArcSchedules,
   ensureOrientationArc,

package/dist/{chunk-RQRO6PC7.js → chunk-VDUCLVZI.js}

@@ -1,22 +1,24 @@
 #!/usr/bin/env node
 import {
   tryGetMindManager
-} from "./chunk-23UJGVYP.js";
+} from "./chunk-WHL6PKYP.js";
 import {
+  clearConfigCache,
   extractTextContent,
   getRoutingConfig,
   resolveDeliveryMode,
   resolveRoute,
+  routesConfigPath,
   setRoutesChangeListener,
   shouldGate
-} from "./chunk-UDZLPR34.js";
+} from "./chunk-YSRYCS3N.js";
 import {
   linkInboundToActiveTurn
-} from "./chunk-VDZ4I4ZP.js";
+} from "./chunk-56IT2ZXF.js";
 import {
   MIND_LEVEL_THREAD,
   newEphemeralSession
-} from "./chunk-IQ7VNWH6.js";
+} from "./chunk-HKGYZVWN.js";
 import {
   publish
 } from "./chunk-LNNI3MS4.js";
@@ -48,14 +50,15 @@ import {
 } from "./chunk-H6X6CKDN.js";
 import {
   channelGates,
+  channels,
   deliveryQueue,
   messages,
   mindHistory
 } from "./chunk-2RNMBXD2.js";
 
 // packages/daemon/src/lib/delivery/delivery-manager.ts
-import { realpath } from "fs/promises";
-import { resolve } from "path";
+import { mkdir, readFile, realpath, rename, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
 import { and as and2, eq as eq2, inArray, sql } from "drizzle-orm";
 
 // packages/daemon/src/lib/chat/typing.ts
@@ -141,8 +144,8 @@ function getTypingMap() {
 function isConversationId(channel) {
   return !channel.startsWith("@") && !channel.startsWith("#") && !channel.includes(":") && !channel.includes("/");
 }
-function publishTypingForChannels(channels, map) {
-  for (const channel of channels) {
+function publishTypingForChannels(channels2, map) {
+  for (const channel of channels2) {
     if (isConversationId(channel)) {
       publish2(channel, { type: "typing", senders: map.get(channel) });
     }
@@ -217,6 +220,25 @@ function formatHoldNotice(channelLabel, unseen) {
 // packages/daemon/src/lib/delivery/delivery-manager.ts
 var dlog = logger_default.child("delivery-manager");
 var MAX_BATCH_SIZE = 50;
+function normalizeChannelKey(channel) {
+  return channel.replace(/^[#@]/, "").toLowerCase();
+}
+function formatSuggestions(suggestions) {
+  const quoted = suggestions.map((s) => `"${s}"`);
+  if (quoted.length <= 1) return quoted.join("");
+  if (quoted.length === 2) return `${quoted[0]} or ${quoted[1]}`;
+  return `${quoted.slice(0, -1).join(", ")}, or ${quoted[quoted.length - 1]}`;
+}
+var UnknownChannelError = class extends Error {
+  constructor(channel, suggestions) {
+    super(
+      `no channel named "${channel}" \u2014 did you mean ${formatSuggestions(suggestions)}? (quote it: the shell strips an unquoted #name)`
+    );
+    this.channel = channel;
+    this.suggestions = suggestions;
+    this.name = "UnknownChannelError";
+  }
+};
 var REDRIVE_INTERVAL_MS = 15e3;
 var RETRY_BASE_MS = 5e3;
 var RETRY_MAX_MS = 5 * 6e4;
@@ -224,6 +246,7 @@ var REDRIVE_BATCH_LIMIT = 200;
 var MAX_DELIVERY_ATTEMPTS = 10;
 var GATED_RELEASE_LIMIT_PER_CHANNEL = 10;
 var GATED_NOTIFY_EVERY = 10;
+var PEEK_LIMIT = 50;
 var mentionRegexCache = /* @__PURE__ */ new Map();
 var avatarBlocksCache = /* @__PURE__ */ new Map();
 var AVATAR_CACHE_TTL = 5 * 60 * 1e3;
@@ -241,17 +264,28 @@ var DeliveryManager = class {
    * messages to the same session can't be reordered by resolvePort/enrichment latency.
    */
   drainChains = /* @__PURE__ */ new Map();
+  /**
+   * Per-`baseName` promise chain that serializes gated releases. `releaseGated` reads gated
+   * rows and then writes `mind_history`; the promote UPDATE is idempotent but the history
+   * INSERT is not, so two overlapping runs would record the same message twice.
+   */
+  releaseChains = /* @__PURE__ */ new Map();
+  /**
+   * Per-`baseName` promise chain serializing accepts, whose read-modify-write of
+   * routes.json would otherwise lose a rule when two run concurrently.
+   */
+  acceptChains = /* @__PURE__ */ new Map();
   redriveTimer = null;
   /** Predicate for whether a mind is up; overridable in tests. */
   isMindRunning = (name) => tryGetMindManager()?.isRunning(name) ?? false;
   /** Delivers a channel event to a mind (invites, release summaries); overridable in tests. */
   notify = async (mindName, text) => {
-    const { deliverEvent } = await import("./system-events-YTOU66QI.js");
+    const { deliverEvent } = await import("./system-events-Q7IVZ5T4.js");
     await deliverEvent(mindName, { type: "channel", body: text });
   };
   /** Surfaces a dead-lettered delivery as a next-turn failure notice; overridable in tests. */
   notifyFailure = async (input) => {
-    const { recordNotice } = await import("./system-events-YTOU66QI.js");
+    const { recordNotice } = await import("./system-events-Q7IVZ5T4.js");
     await recordNotice(input);
   };
   /**
@@ -259,7 +293,7 @@ var DeliveryManager = class {
    * side); no-ops for human senders. Overridable in tests.
    */
   notifySenderFailure = async (sender, channel, reason) => {
-    const { recordSenderDeliveryFailure } = await import("./delivery-notices-65TB3CBX.js");
+    const { recordSenderDeliveryFailure } = await import("./delivery-notices-RZQ6GONP.js");
     await recordSenderDeliveryFailure(sender, channel, reason);
   };
   constructor() {
@@ -456,9 +490,27 @@ var DeliveryManager = class {
    *    in one sweep (#537 bug 2), and the mind gets one summary rather than a flood.
    * Rows resolving to a `file` destination are archived (the delivery manager doesn't
    * deliver file routes). Declined channels are skipped entirely — they stay gated.
+   *
+   * Releases are serialized per mind: the promote step reads gated rows and then writes
+   * `mind_history`, and while the promote UPDATE is idempotent the history INSERT is not —
+   * two overlapping runs would both see the same rows and record the message twice.
    */
   async releaseGated(mindName) {
     const baseName = await getBaseName(mindName);
+    const prev = this.releaseChains.get(baseName) ?? Promise.resolve();
+    const run = prev.then(() => this.releaseGatedInner(mindName, baseName));
+    const chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.releaseChains.set(baseName, chain);
+    try {
+      return await run;
+    } finally {
+      if (this.releaseChains.get(baseName) === chain) this.releaseChains.delete(baseName);
+    }
+  }
+  async releaseGatedInner(mindName, baseName) {
     const config = getRoutingConfig(baseName);
     let rows;
     try {
@@ -466,7 +518,7 @@ var DeliveryManager = class {
       rows = await db.select().from(deliveryQueue).where(and2(eq2(deliveryQueue.mind, baseName), eq2(deliveryQueue.status, "gated")));
     } catch (err) {
       dlog.warn(`failed to read gated rows for ${baseName}`, logger_default.errorData(err));
-      return;
+      return { released: 0, archived: 0 };
     }
     const byChannel = /* @__PURE__ */ new Map();
     const archiveIds = [];
@@ -515,7 +567,7 @@ var DeliveryManager = class {
       for (const d of drop) archiveIds.push(d.id);
       if (drop.length > 0) {
         truncationNotes.push(
-          `${channel}: released the ${keep.length} most recent message(s); ${drop.length} earlier message(s) were held while unrouted and remain in the channel history (volute chat read ${channel}).`
+          `${channel}: released the ${keep.length} most recent message(s); ${drop.length} earlier message(s) were held while unrouted and stay readable (volute chat channels peek "${channel}").`
         );
         dlog.info(
           `truncated gated release for ${baseName} on ${channel}: kept ${keep.length}, archived ${drop.length}`
@@ -534,9 +586,10 @@ var DeliveryManager = class {
     }
     if (promote.length === 0) {
       if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
-      return;
+      return { released: 0, archived: archiveIds.length };
     }
     const orderedPromote = [...promote].sort((a, b) => a.id - b.id);
+    let committed = 0;
     try {
       const db = await getDb();
       for (const p of orderedPromote) {
@@ -550,14 +603,15 @@ var DeliveryManager = class {
           });
           await tx.update(deliveryQueue).set({ status: "pending", thread: p.session, attempts: 0, next_attempt_at: null }).where(eq2(deliveryQueue.id, p.id));
         });
+        committed++;
       }
-      dlog.info(`released ${promote.length} gated message(s) for ${baseName} after route change`);
+      dlog.info(`released ${committed} gated message(s) for ${baseName} after route change`);
     } catch (err) {
       dlog.error(
         `failed to record+promote gated rows for ${baseName} (channels: ${[...byChannel.keys()].join(", ")})`,
         logger_default.errorData(err)
       );
-      return;
+      return { released: committed, archived: archiveIds.length };
     }
     for (const p of orderedPromote) {
       publish(baseName, {
@@ -570,6 +624,63 @@ var DeliveryManager = class {
     }
     if (truncationNotes.length > 0) await this.sendReleaseSummary(mindName, truncationNotes);
     await this.redrive();
+    return { released: committed, archived: archiveIds.length };
+  }
+  /**
+   * Channels this mind could plausibly mean, from three sources:
+   *
+   * 1. Its current queue rows — channels with a live `gated`/`archived`/`pending` backlog.
+   * 2. Its own history — the durable record. Source 1 alone is not enough: delivered rows
+   *    are *deleted* (`deleteQueueRows`), so a channel the mind has been using
+   *    successfully for months drops out of the queue entirely, and an external-platform
+   *    channel like `discord:general` is in no other table. Without this, the healthier
+   *    the channel, the more likely we'd call it unrecognized.
+   * 3. Every *public* Volute channel, so a channel can be recognized before its first
+   *    message ever arrives.
+   *
+   * Private channels are deliberately excluded from source 3. This set feeds the "did you
+   * mean X?" suggestion, so anything in it can be echoed back to a mind that guessed a
+   * nearby name — which would turn a typo into a way to confirm a private channel exists
+   * and learn its exact slug. Minds are untrusted principals. A private channel the mind
+   * is genuinely in still resolves via sources 1 and 2, which are scoped to it.
+   */
+  async knownChannels(baseName) {
+    const db = await getDb();
+    const queued = await db.selectDistinct({ channel: deliveryQueue.channel }).from(deliveryQueue).where(eq2(deliveryQueue.mind, baseName));
+    const seen = await db.selectDistinct({ channel: mindHistory.channel }).from(mindHistory).where(eq2(mindHistory.mind, baseName));
+    const named = await db.selectDistinct({ name: channels.name }).from(channels).where(eq2(channels.private, 0));
+    const out = /* @__PURE__ */ new Set();
+    for (const r of queued) if (r.channel) out.add(r.channel);
+    for (const r of seen) if (r.channel) out.add(r.channel);
+    for (const r of named) out.add(`#${r.name}`);
+    return [...out];
+  }
+  /**
+   * Match a channel name the caller supplied against the channels that actually exist.
+   *
+   * The failure this exists to prevent: a mind is told to run `... accept #garden`, hits
+   * the shell's comment character, drops the `#` to "fix" it, and accepts `garden` — a
+   * name nothing will ever send from. That wrote a permanent junk rule to routes.json and
+   * reported success, leaving the mind believing it had joined a channel it could send to
+   * but would never hear from. A one-way channel it had no reason to doubt.
+   *
+   * A near-miss (same name modulo sigil and case) is reported so callers can refuse with
+   * the real slug. A name with no near-miss is *not* an error — pre-routing a channel
+   * before its first message arrives is legitimate — but it comes back `known: false` so
+   * callers can say plainly that nothing was recognized instead of implying a join.
+   */
+  async matchChannelName(baseName, channel) {
+    let all;
+    try {
+      all = await this.knownChannels(baseName);
+    } catch (err) {
+      dlog.warn(`failed to list known channels for ${baseName}`, logger_default.errorData(err));
+      return { known: true, suggestions: [] };
+    }
+    if (all.includes(channel)) return { known: true, suggestions: [] };
+    const key = normalizeChannelKey(channel);
+    const near = all.filter((c) => normalizeChannelKey(c) === key).sort();
+    return { known: false, suggestions: near };
   }
   /**
    * Whether the mind has explicitly declined a channel. A declined channel keeps
@@ -593,6 +704,8 @@ var DeliveryManager = class {
    */
   async declineChannel(mindName, channel) {
     const baseName = await getBaseName(mindName);
+    const match = await this.matchChannelName(baseName, channel);
+    if (match.suggestions.length > 0) throw new UnknownChannelError(channel, match.suggestions);
     const db = await getDb();
     await db.insert(channelGates).values({ mind: baseName, channel, state: "declined" }).onConflictDoUpdate({
       target: [channelGates.mind, channelGates.channel],
@@ -610,6 +723,163 @@ var DeliveryManager = class {
     );
     return archived.length;
   }
+  /**
+   * Accept an unrouted (gated) channel: add a routing rule for it to the mind's routes.json
+   * and release its held messages immediately.
+   *
+   * This exists because a hand-edited routes.json is only noticed lazily, when the *next*
+   * inbound message triggers a config read — so editing the file on a quiet mind releases
+   * nothing and the held messages sit there indefinitely. Accept applies the change and
+   * reports what it actually released. #537
+   */
+  async acceptChannel(mindName, channel, thread) {
+    const baseName = await getBaseName(mindName);
+    const prev = this.acceptChains.get(baseName) ?? Promise.resolve();
+    const run = prev.then(() => this.acceptChannelInner(mindName, baseName, channel, thread));
+    const chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.acceptChains.set(baseName, chain);
+    try {
+      return await run;
+    } finally {
+      if (this.acceptChains.get(baseName) === chain) this.acceptChains.delete(baseName);
+    }
+  }
+  async acceptChannelInner(mindName, baseName, channel, thread) {
+    const match = await this.matchChannelName(baseName, channel);
+    if (match.suggestions.length > 0) throw new UnknownChannelError(channel, match.suggestions);
+    const path = routesConfigPath(baseName);
+    let config;
+    try {
+      const parsed = JSON.parse(await readFile(path, "utf-8"));
+      if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`routes.json for ${baseName} is malformed (not a JSON object)`);
+      }
+      config = parsed;
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        throw new Error(
+          `routes.json for ${baseName} is unreadable or malformed \u2014 not modifying it`
+        );
+      }
+      config = {};
+    }
+    const rules = Array.isArray(config.rules) ? config.rules : [];
+    const targetThread = thread ?? "${channel}";
+    const existing = resolveRoute({ ...config, rules }, { channel });
+    const ruleAdded = !existing.matched;
+    if (ruleAdded) {
+      rules.push({ channel, thread: targetThread });
+      config.rules = rules;
+      await mkdir(dirname(path), { recursive: true });
+      const tmp = `${path}.${process.pid}.tmp`;
+      await writeFile(tmp, `${JSON.stringify(config, null, 2)}
+`);
+      await rename(tmp, path);
+    }
+    const db = await getDb();
+    await db.delete(channelGates).where(and2(eq2(channelGates.mind, baseName), eq2(channelGates.channel, channel)));
+    const heldBefore = await db.select({ id: deliveryQueue.id }).from(deliveryQueue).where(
+      and2(
+        eq2(deliveryQueue.mind, baseName),
+        eq2(deliveryQueue.channel, channel),
+        eq2(deliveryQueue.status, "gated")
+      )
+    );
+    clearConfigCache(baseName, { notify: false });
+    await this.releaseGated(mindName);
+    let released = 0;
+    let archived = 0;
+    const ids = heldBefore.map((r) => r.id);
+    for (let i = 0; i < ids.length; i += 500) {
+      const after = await db.select({ status: deliveryQueue.status }).from(deliveryQueue).where(inArray(deliveryQueue.id, ids.slice(i, i + 500)));
+      for (const row of after) {
+        if (row.status === "archived") archived++;
+        else if (row.status !== "gated") released++;
+      }
+    }
+    dlog.info(
+      `accepted channel ${channel} for ${baseName} (rule ${ruleAdded ? "added" : "already present"}); released ${released}, archived ${archived}`
+    );
+    const finalRoute = ruleAdded ? resolveRoute({ ...config, rules }, { channel }) : existing;
+    return {
+      ruleAdded,
+      thread: finalRoute.destination === "file" ? finalRoute.path : finalRoute.session,
+      released,
+      archived,
+      known: match.known
+    };
+  }
+  /**
+   * Read the messages held on a channel without changing anything. Archived rows are
+   * included: a truncated or declined backlog stays readable, which is what the invite and
+   * release-summary texts promise. Gated messages have no conversation, so `volute chat
+   * read` can't show them — this is the only way to see them.
+   *
+   * Returns the most recent {@link PEEK_LIMIT} messages (oldest-first within that window)
+   * alongside the true total, so peeking at a spam channel with a huge backlog can't dump
+   * all of it into the mind's context — the same reason releases are truncated. #537
+   */
+  async peekChannel(mindName, channel) {
+    const baseName = await getBaseName(mindName);
+    const db = await getDb();
+    const rows = await db.select().from(deliveryQueue).where(
+      and2(
+        eq2(deliveryQueue.mind, baseName),
+        eq2(deliveryQueue.channel, channel),
+        inArray(deliveryQueue.status, ["gated", "archived"])
+      )
+    );
+    const messages2 = rows.sort((a, b) => a.id - b.id).slice(-PEEK_LIMIT).map((row) => {
+      let content = "";
+      try {
+        content = extractTextContent(JSON.parse(row.payload).content);
+      } catch {
+        content = "(unreadable payload)";
+      }
+      return {
+        sender: row.sender,
+        content,
+        createdAt: row.created_at,
+        status: row.status
+      };
+    });
+    const near = rows.length === 0 ? (await this.matchChannelName(baseName, channel)).suggestions : [];
+    return {
+      channel,
+      count: rows.length,
+      shown: messages2.length,
+      suggestions: near.length > 0 ? near : void 0,
+      messages: messages2
+    };
+  }
+  /**
+   * Re-evaluate every mind's held messages against its current routes.json. Run at daemon
+   * startup: routes.json edits made while the daemon was down would otherwise not be noticed
+   * until the next inbound message on that channel — which, for a quiet channel, may be never.
+   */
+  async releaseGatedSweep() {
+    let minds;
+    try {
+      const db = await getDb();
+      minds = await db.selectDistinct({ mind: deliveryQueue.mind }).from(deliveryQueue).where(eq2(deliveryQueue.status, "gated"));
+    } catch (err) {
+      dlog.warn("failed to list minds with gated messages", logger_default.errorData(err));
+      return;
+    }
+    for (const { mind } of minds) {
+      try {
+        const { released, archived } = await this.releaseGated(mind);
+        if (released > 0 || archived > 0) {
+          dlog.info(`startup sweep for ${mind}: released ${released}, archived ${archived}`);
+        }
+      } catch (err) {
+        dlog.warn(`startup gated sweep failed for ${mind}`, logger_default.errorData(err));
+      }
+    }
+  }
   /**
    * Send the mind a single summary when a routing change released a truncated backlog,
    * rather than a flood of individual messages. #537
@@ -872,8 +1142,8 @@ var DeliveryManager = class {
       const to = r.target_mind && r.target_mind !== r.mind ? ` to your variant ${r.target_mind}` : "";
       return `- a message${from}${on}${to} (sent ${r.created_at})`;
     });
-    const channels = [...new Set(rows.map((r) => r.channel).filter((c) => !!c))];
-    const recovery = channels.length > 0 ? `The original message(s) remain in the channel history \u2014 read them with ${channels.map((c) => `\`volute chat read ${c}\``).join(" or ")}.` : `The original message(s) remain in the channel history.`;
+    const channels2 = [...new Set(rows.map((r) => r.channel).filter((c) => !!c))];
+    const recovery = channels2.length > 0 ? `The original message(s) remain in the channel history \u2014 read them with ${channels2.map((c) => `\`volute chat read ${c}\``).join(" or ")}.` : `The original message(s) remain in the channel history.`;
     const detail = [
       `${rows.length} message(s) sent to you could not be delivered after ${MAX_DELIVERY_ATTEMPTS} attempts and were dropped:`,
       ...lines,
@@ -922,9 +1192,9 @@ ${channel}`, { sender: r.sender, channel });
       const { baseName, port } = resolved;
       const senders = /* @__PURE__ */ new Set();
       if (payload.sender) senders.add(payload.sender);
-      const channels = /* @__PURE__ */ new Set();
-      if (payload.channel) channels.add(payload.channel);
-      this.incrementActive(baseName, session, senders, channels);
+      const channels2 = /* @__PURE__ */ new Set();
+      if (payload.channel) channels2.add(payload.channel);
+      this.incrementActive(baseName, session, senders, channels2);
       await onDeliveredToMind(baseName, payload.conversationId);
       linkInboundToActiveTurn(baseName, session, payload.channel).catch(
         (err) => dlog.warn(`failed to link mid-turn inbound for ${baseName}`, logger_default.errorData(err))
@@ -942,7 +1212,8 @@ ${channel}`, { sender: r.sender, channel });
       const body = JSON.stringify({
         ...enrichedPayload,
         session,
-        instructions: sessionConfig.instructions
+        instructions: sessionConfig.instructions,
+        interrupt: sessionConfig.interrupt
       });
       try {
         const ok = await this.postToMind(port, body);
@@ -987,11 +1258,11 @@ ${channel}`, { sender: r.sender, channel });
           return { ...msg, payload: enrichedPayload };
         })
       );
-      const channels = {};
+      const channels2 = {};
       for (const msg of enrichedMessages) {
         const ch = msg.channel ?? "unknown";
-        if (!channels[ch]) channels[ch] = [];
-        channels[ch].push(msg.payload);
+        if (!channels2[ch]) channels2[ch] = [];
+        channels2[ch].push(msg.payload);
       }
       const senders = /* @__PURE__ */ new Set();
       const channelSet = /* @__PURE__ */ new Set();
@@ -1013,7 +1284,7 @@ ${channel}`, { sender: r.sender, channel });
         );
       }
       const typingMap = getTypingMap();
-      for (const ch of Object.keys(channels)) {
+      for (const ch of Object.keys(channels2)) {
         if (ch !== "unknown") typingMap.set(ch, baseName, { persistent: true });
       }
       const seenConvIds = /* @__PURE__ */ new Set();
@@ -1028,8 +1299,9 @@ ${channel}`, { sender: r.sender, channel });
       }
       const body = JSON.stringify({
         session,
-        batch: { channels },
-        instructions: sessionConfig.instructions
+        batch: { channels: channels2 },
+        instructions: sessionConfig.instructions,
+        interrupt: sessionConfig.interrupt
       });
       try {
         const ok = await this.postToMind(port, body);
@@ -1164,7 +1436,7 @@ ${channel}`, { sender: r.sender, channel });
     const details = detailLines.length > 0 ? `${detailLines.join("\n")}
 
 ` : "\n";
-    const { getPrompt } = await import("./prompts-HNKGCAEY.js");
+    const { getPrompt } = await import("./prompts-JECJIFPQ.js");
     const notification = await getPrompt("channel_invite", {
       channel,
       heldLine,
@@ -1284,7 +1556,7 @@ ${channel}`, { sender: r.sender, channel });
     avatarBlocksCache.set(cacheKey, { blocks, expiresAt: now + AVATAR_CACHE_TTL });
     return blocks;
   }
-  incrementActive(mind, session, senders, channels) {
+  incrementActive(mind, session, senders, channels2) {
     let mindSessions = this.sessionStates.get(mind);
     if (!mindSessions) {
       mindSessions = /* @__PURE__ */ new Map();
@@ -1300,7 +1572,7 @@ ${channel}`, { sender: r.sender, channel });
     state2.activeCount++;
     state2.lastDeliveredAt = Date.now();
     if (senders) state2.lastDeliverySenders = senders;
-    if (channels) state2.lastDeliveryChannels = channels;
+    if (channels2) state2.lastDeliveryChannels = channels2;
     mindSessions.set(session, state2);
   }
   decrementActive(mind, session) {
@@ -1343,6 +1615,8 @@ export {
   publishTypingForChannels,
   checkStaleSend,
   formatHoldNotice,
+  formatSuggestions,
+  UnknownChannelError,
   MAX_DELIVERY_ATTEMPTS,
   DeliveryManager,
   initDeliveryManager,