volute 0.51.0 → 0.53.0

package/dist/{chunk-DMK5ASKV.js → chunk-F6D766VQ.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
 import {
   stateDir
 } from "./chunk-H6X6CKDN.js";
@@ -7,6 +10,7 @@ import {
 import { randomBytes } from "crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { basename, join, normalize, resolve } from "path";
+var flog = logger_default.child("file-sharing");
 function validateFilePath(filePath) {
   if (!filePath) return "File path is required";
   const normalized = normalize(filePath);
@@ -65,7 +69,7 @@ function listPending(receiver) {
     try {
       result.push(JSON.parse(readFileSync(metaPath, "utf-8")));
     } catch (err) {
-      console.warn(`[file-sharing] skipping malformed pending entry ${entry.name}:`, err);
+      flog.warn(`skipping malformed pending entry ${entry.name}`, logger_default.errorData(err));
     }
   }
   return result.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
@@ -77,7 +81,7 @@ function getPending(receiver, id) {
   try {
     return JSON.parse(readFileSync(metaPath, "utf-8"));
   } catch (err) {
-    console.warn(`[file-sharing] failed to read pending metadata for ${id}:`, err);
+    flog.warn(`failed to read pending metadata for ${id}`, logger_default.errorData(err));
     return null;
   }
 }

package/dist/{chunk-VP5PFNZO.js → chunk-HASADR3E.js}

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import {
   spiritDir
-} from "./chunk-VSBMLB2W.js";
+} from "./chunk-5DBGQBQR.js";
 import {
   getScheduler
-} from "./chunk-Q7XQLKZB.js";
+} from "./chunk-PIZDPY4G.js";
 import {
   getDeliveryManager
-} from "./chunk-7HN63Q7J.js";
+} from "./chunk-RQRO6PC7.js";
 import {
   getMindManager,
   resolveMindToken
-} from "./chunk-VAEZCIJC.js";
+} from "./chunk-23UJGVYP.js";
 import {
   extractTextContent,
   getRoutingConfig,
@@ -23,14 +23,14 @@ import {
   importSkillFromDir,
   removeSharedSkill,
   sharedSkillsDir
-} from "./chunk-QT4D5XCI.js";
+} from "./chunk-TAWRJ24T.js";
 import {
   getOrCreateMindUser,
   getOrCreateSystemUser,
   getUser,
   getUserByUsername,
   syncMindProfile
-} from "./chunk-HKP6OAJP.js";
+} from "./chunk-7LT3YZUR.js";
 import {
   MIND_LEVEL_THREAD,
   deliverEvent,
@@ -38,13 +38,13 @@ import {
   pendingEventCount,
   pendingEventsLine,
   recordNotice
-} from "./chunk-ICL6T4SN.js";
+} from "./chunk-IQ7VNWH6.js";
 import {
   publish as publish2
 } from "./chunk-LNNI3MS4.js";
 import {
   getPrompt
-} from "./chunk-FXWBFDQR.js";
+} from "./chunk-AP2KQMMW.js";
 import {
   addMessage,
   createChannel,
@@ -891,8 +891,16 @@ async function startMindFull(name) {
     (err) => logger_default.error(`failed to ensure system DM for ${baseName}`, logger_default.errorData(err))
   );
   const dir = mindDir(baseName);
-  getScheduler().loadSchedules(baseName);
-  getSleepManagerIfReady()?.loadSleepConfig(baseName);
+  try {
+    getScheduler().loadSchedules(baseName);
+  } catch (err) {
+    logger_default.error(`failed to load schedules for ${baseName}`, logger_default.errorData(err));
+  }
+  try {
+    getSleepManagerIfReady()?.loadSleepConfig(baseName);
+  } catch (err) {
+    logger_default.error(`failed to load sleep config for ${baseName}`, logger_default.errorData(err));
+  }
   ensureMailAddress(baseName).catch(
     (err) => logger_default.error(`failed to ensure mail address for ${baseName}`, logger_default.errorData(err))
   );
@@ -906,16 +914,24 @@ async function startMindFull(name) {
     (err) => logger_default.warn(`failed to join #system for ${baseName}`, logger_default.errorData(err))
   );
   if (config?.tokenBudget) {
-    getTokenBudget().setBudget(
-      baseName,
-      config.tokenBudget,
-      config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
-    );
+    try {
+      getTokenBudget().setBudget(
+        baseName,
+        config.tokenBudget,
+        config.tokenBudgetPeriodMinutes ?? DEFAULT_BUDGET_PERIOD_MINUTES
+      );
+    } catch (err) {
+      logger_default.error(`failed to set token budget for ${baseName}`, logger_default.errorData(err));
+    }
+  }
+  try {
+    notifyExtensionsMindStart(baseName);
+  } catch (err) {
+    logger_default.error(`failed to notify extensions of mind start for ${baseName}`, logger_default.errorData(err));
   }
-  notifyExtensionsMindStart(baseName);
 }
 async function recordMissingCredentialsNotice(mind, template) {
-  const { hasUndeliveredEvent, recordNotice: recordNotice2, MIND_LEVEL_THREAD: MIND_LEVEL_THREAD2 } = await import("./system-events-ZPSH63QX.js");
+  const { hasUndeliveredEvent, recordNotice: recordNotice2, MIND_LEVEL_THREAD: MIND_LEVEL_THREAD2 } = await import("./system-events-YTOU66QI.js");
   const warning = await missingCredentialWarning(template, readMindModel(mind, template), mind);
   if (!warning) return;
   if (await hasUndeliveredEvent(mind, "no_credentials")) return;
@@ -992,7 +1008,7 @@ function buildSeedOrientation(createdBy, creatorType) {
 async function sendSeedOrientation(mindName, createdBy) {
   let creatorType;
   if (createdBy) {
-    const { getUserByUsername: getUserByUsername2 } = await import("./auth-X6EMNEGB.js");
+    const { getUserByUsername: getUserByUsername2 } = await import("./auth-KRDSM55Q.js");
     creatorType = (await getUserByUsername2(createdBy))?.user_type;
   }
   await deliverEvent(mindName, {
@@ -1001,7 +1017,7 @@ async function sendSeedOrientation(mindName, createdBy) {
   });
 }
 async function ensureCreatorDM(mindName, creatorUsername) {
-  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-X6EMNEGB.js");
+  const { getOrCreateMindUser: getOrCreateMindUser2, getUserByUsername: getUserByUsername2 } = await import("./auth-KRDSM55Q.js");
   const { findDMConversation: findDMConversation2, createConversation: createConversation2 } = await import("./conversations-ZL6PHROD.js");
   const mindUser = await getOrCreateMindUser2(mindName);
   const creatorUser = await getUserByUsername2(creatorUsername);
@@ -1174,6 +1190,13 @@ var SleepManager = class {
     this.transitioning.add(name);
     state.wokenByTrigger = false;
     try {
+      await recordNotice({
+        mind: name,
+        thread: MIND_LEVEL_THREAD,
+        kind: "crash",
+        reason: "trigger_wake_crash",
+        detail: await getPrompt("trigger_wake_crash_notice")
+      });
       try {
         await sleepMind(name);
       } catch (err) {
@@ -1230,6 +1253,15 @@ var SleepManager = class {
       const wakeTime = formatWakeTime(wakeAt);
       const preSleepMsg = await getPrompt("pre_sleep", { wakeTime });
       const { delivered } = await deliverEvent(name, { type: "sleep", body: preSleepMsg });
+      if (!delivered) {
+        await recordNotice({
+          mind: name,
+          thread: MIND_LEVEL_THREAD,
+          kind: "delivery_failed",
+          reason: "pre_sleep_failed",
+          detail: await getPrompt("pre_sleep_failure_notice")
+        });
+      }
       if (delivered) await this.waitForIdle(name, 12e4);
       await new Promise((r) => setTimeout(r, 3e3));
       await sleepMind(name);
@@ -1420,7 +1452,7 @@ var SleepManager = class {
    * the real delivery stack. Returns whether the batch was handed off to the mind.
    */
   async deliverQueuedBatch(name, payloads) {
-    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-JHMAJ2GU.js");
+    const { deliverBatch: deliverBatch2 } = await import("./message-delivery-TUXM3AAE.js");
     return deliverBatch2(name, payloads);
   }
   // --- Wake failure handling (#419) ---
@@ -1647,6 +1679,22 @@ var SleepManager = class {
         }
       }
     }
+    const codexSessionsDir = resolve4(dir, ".mind", "codex-sessions");
+    if (existsSync4(codexSessionsDir)) {
+      const archiveDir = resolve4(codexSessionsDir, "archive");
+      mkdirSync2(archiveDir, { recursive: true });
+      for (const file of readdirSync(codexSessionsDir)) {
+        if (file === "archive" || !file.endsWith(".json")) continue;
+        const src = resolve4(codexSessionsDir, file);
+        const base = file.replace(/\.json$/, "");
+        const dest = resolve4(archiveDir, `${base}-${timestamp}.json`);
+        try {
+          renameSync(src, dest);
+        } catch (err) {
+          slog.warn(`failed to archive codex-session ${file} for ${name}`, logger_default.errorData(err));
+        }
+      }
+    }
   }
   async runWakeContextScript(name, sleepingSince, duration) {
     const scriptPath = resolve4(mindDir(name), "home", ".local", "hooks", "wake-context.sh");
@@ -1945,6 +1993,10 @@ function willGate(baseName, payload) {
   });
   return shouldGate(config, route);
 }
+async function willGateMessage(mindName, payload) {
+  const baseName = await getBaseName(mindName);
+  return willGate(baseName, payload);
+}
 async function deliverMessage(mindName, payload, opts = {}) {
   try {
     const baseName = await getBaseName(mindName);
@@ -2894,6 +2946,7 @@ export {
   recordOutbound,
   linkToolResultToTurn,
   resolveSleepAction,
+  willGateMessage,
   deliverMessage,
   deliverBatch,
   ensureSystemChannel,

package/dist/{chunk-ICL6T4SN.js → chunk-IQ7VNWH6.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-2RNMBXD2.js";
 
 // packages/daemon/src/lib/chat/system-events.ts
-import { and, asc, desc, eq, gt, isNull, lte, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gt, isNotNull, isNull, lt, lte, or, sql } from "drizzle-orm";
 
 // packages/daemon/src/lib/util/session-name.ts
 function newEphemeralSession() {
@@ -29,6 +29,7 @@ var elog = logger_default.child("system-events");
 var MIND_LEVEL_THREAD = "";
 var MAX_NEXT_TURN_EVENTS = 100;
 var FLUSH_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var EVENT_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 function parseMeta(meta, context) {
   if (!meta) return {};
   try {
@@ -93,6 +94,10 @@ function eventLabel(type, meta) {
           return s("reason") ? `Notice: ${s("reason")}` : "Notice";
         case "delivery_failed":
           return "Delivery failed";
+        case "context_lost":
+          return "Context lost";
+        case "join_blocked":
+          return "Variant join blocked";
         default:
           return "Notice";
       }
@@ -100,6 +105,16 @@ function eventLabel(type, meta) {
       return type.charAt(0).toUpperCase() + type.slice(1);
   }
 }
+var NOTICE_KINDS = [
+  "turn_error",
+  "crash",
+  "budget",
+  "startup",
+  "extension",
+  "delivery_failed",
+  "context_lost",
+  "join_blocked"
+];
 async function recordNotice(input) {
   const type = input.kind === "budget" ? "budget" : "notice";
   await deliverEvent(input.mind, {
@@ -108,6 +123,7 @@ async function recordNotice(input) {
     thread: input.thread,
     delivery: "next-turn",
     meta: {
+      ...input.meta ?? {},
       subtype: input.kind,
       reason: input.reason,
       ...input.raw ? { raw: input.raw } : {}
@@ -241,7 +257,7 @@ async function deliverEvent(mind, input) {
       return { id: eventId, delivered: false };
     }
     const baseName = await getBaseName(mind);
-    const { getSleepManagerIfReady } = await import("./sleep-manager-7JXEQQ2P.js");
+    const { getSleepManagerIfReady } = await import("./sleep-manager-NWUCRBZB.js");
     const sleepManager = getSleepManagerIfReady();
     const sleeping = !input.force && sleepManager?.isSleeping(baseName);
     const behavior = input.whileSleeping ?? "queue";
@@ -325,6 +341,11 @@ async function pendingEventCount(mind) {
     return 0;
   }
 }
+async function cleanExpiredEvents() {
+  const db = await getDb();
+  const cutoff = new Date(Date.now() - EVENT_RETENTION_MS).toISOString().replace("T", " ").slice(0, 19);
+  await db.delete(systemEvents).where(and(isNotNull(systemEvents.delivered_at), lt(systemEvents.created_at, cutoff)));
+}
 function pendingEventsLine(count) {
   if (count <= 0) return "";
   return `${count} system event${count === 1 ? "" : "s"} arrived while you slept and will follow shortly.`;
@@ -544,14 +565,17 @@ export {
   MIND_LEVEL_THREAD,
   parseMeta,
   eventLabel,
+  NOTICE_KINDS,
   recordNotice,
   eventChannel,
   deliverEvent,
   flushQueuedEvents,
   pendingEventCount,
+  cleanExpiredEvents,
   pendingEventsLine,
   drainEvents,
   formatEvents,
+  localHM,
   clearDeliveredEvents,
   latestFailureEvent,
   latestEvent,

package/dist/{chunk-G7A5LEVI.js → chunk-LN7XJ56R.js}

@@ -6,6 +6,10 @@ import {
 import {
   resolveMindName
 } from "./chunk-BTY4WNFE.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
 import {
   daemonFetch
 } from "./chunk-M74I3HHF.js";
@@ -13,10 +17,6 @@ import {
   getClient,
   urlOf
 } from "./chunk-LOPXTW6H.js";
-import {
-  command,
-  subcommands
-} from "./chunk-TXSA4Q3V.js";
 
 // packages/cli/src/commands/clock.ts
 import { CronExpressionParser } from "cron-parser";
@@ -279,11 +279,11 @@ var cmd = subcommands({
     },
     sleep: {
       description: "Put a mind to sleep",
-      run: (args) => import("./mind-sleep-LZAFBDZD.js").then((m) => m.run(args))
+      run: (args) => import("./mind-sleep-D3DEYAWG.js").then((m) => m.run(args))
     },
     wake: {
       description: "Wake a sleeping mind",
-      run: (args) => import("./mind-wake-LDGPRA42.js").then((m) => m.run(args))
+      run: (args) => import("./mind-wake-DCDFFQKX.js").then((m) => m.run(args))
     }
   },
   footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."

package/dist/{chunk-DN3LKLYR.js → chunk-P2TBUKLW.js}

@@ -2,14 +2,14 @@
 import {
   getSleepManagerIfReady,
   startSpiritFull
-} from "./chunk-VP5PFNZO.js";
+} from "./chunk-HASADR3E.js";
 import {
   spiritCreationInProgress
-} from "./chunk-VSBMLB2W.js";
+} from "./chunk-5DBGQBQR.js";
 import {
   MindStartupError,
   tryGetMindManager
-} from "./chunk-VAEZCIJC.js";
+} from "./chunk-23UJGVYP.js";
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";

package/dist/{chunk-Q7XQLKZB.js → chunk-PIZDPY4G.js}

@@ -6,10 +6,15 @@ import {
   getMindToken,
   loadJsonMap,
   saveJsonMapAsync
-} from "./chunk-VAEZCIJC.js";
+} from "./chunk-23UJGVYP.js";
 import {
-  deliverEvent
-} from "./chunk-ICL6T4SN.js";
+  MIND_LEVEL_THREAD,
+  deliverEvent,
+  recordNotice
+} from "./chunk-IQ7VNWH6.js";
+import {
+  getPrompt
+} from "./chunk-AP2KQMMW.js";
 import {
   isSandboxEnabled,
   wrapForSandbox
@@ -197,6 +202,18 @@ ${stderr}` : ""}`;
       }
     } catch (err) {
       slog.warn(`failed to fire "${schedule.id}" for ${mindName}`, logger_default.errorData(err));
+      const detail = await getPrompt("schedule_failure_notice", {
+        id: schedule.id,
+        reason: err instanceof Error && err.message ? err.message : String(err)
+      });
+      const thread = schedule.thread && !schedule.thread.startsWith("new-") ? schedule.thread : MIND_LEVEL_THREAD;
+      await recordNotice({
+        mind: mindName,
+        thread,
+        kind: "delivery_failed",
+        reason: "schedule_failed",
+        detail
+      });
     }
   }
   removeSchedule(mindName, scheduleId) {

package/dist/{chunk-JHKBALS2.js → chunk-RMADJFA7.js}

@@ -2,7 +2,7 @@
 import {
   MEMORY_PLACEHOLDER_MARKER,
   ORIENTATION_MARKER
-} from "./chunk-FXWBFDQR.js";
+} from "./chunk-AP2KQMMW.js";
 import {
   safeResolveWithinBase
 } from "./chunk-DW4TRDOZ.js";

package/dist/{chunk-7HN63Q7J.js → chunk-RQRO6PC7.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   tryGetMindManager
-} from "./chunk-VAEZCIJC.js";
+} from "./chunk-23UJGVYP.js";
 import {
   extractTextContent,
   getRoutingConfig,
@@ -12,11 +12,11 @@ import {
 } from "./chunk-UDZLPR34.js";
 import {
   linkInboundToActiveTurn
-} from "./chunk-CDKQJWGK.js";
+} from "./chunk-VDZ4I4ZP.js";
 import {
   MIND_LEVEL_THREAD,
   newEphemeralSession
-} from "./chunk-ICL6T4SN.js";
+} from "./chunk-IQ7VNWH6.js";
 import {
   publish
 } from "./chunk-LNNI3MS4.js";
@@ -36,6 +36,9 @@ import {
 import {
   logger_default
 } from "./chunk-QUSMYGNQ.js";
+import {
+  slugify
+} from "./chunk-LGNUFVMR.js";
 import {
   findMind,
   getBaseName,
@@ -243,14 +246,22 @@ var DeliveryManager = class {
   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-ZPSH63QX.js");
+    const { deliverEvent } = await import("./system-events-YTOU66QI.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-ZPSH63QX.js");
+    const { recordNotice } = await import("./system-events-YTOU66QI.js");
     await recordNotice(input);
   };
+  /**
+   * Tells a mind *sender* its message was dropped (dead-lettered on the recipient's
+   * side); no-ops for human senders. Overridable in tests.
+   */
+  notifySenderFailure = async (sender, channel, reason) => {
+    const { recordSenderDeliveryFailure } = await import("./delivery-notices-65TB3CBX.js");
+    await recordSenderDeliveryFailure(sender, channel, reason);
+  };
   constructor() {
     setRoutesChangeListener((mind) => {
       this.releaseGated(mind).catch(
@@ -270,6 +281,10 @@ var DeliveryManager = class {
   setFailureNotifier(fn) {
     this.notifyFailure = fn;
   }
+  /** Test seam: capture/override sender-side dead-letter notices. */
+  setSenderFailureNotifier(fn) {
+    this.notifySenderFailure = fn;
+  }
   // --- Public API ---
   /**
    * Route and deliver a message to a mind. This is the main entry point.
@@ -875,6 +890,25 @@ var DeliveryManager = class {
     } catch (err) {
       dlog.warn(`failed to send dead-letter notice for ${mind}`, logger_default.errorData(err));
     }
+    const senderPairs = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if (!r.sender || r.sender === r.mind) continue;
+      const recipient = r.target_mind ?? r.mind;
+      const channel = !r.channel || r.channel === `@${slugify(r.sender)}` ? `@${recipient}` : r.channel;
+      senderPairs.set(`${r.sender}
+${channel}`, { sender: r.sender, channel });
+    }
+    for (const { sender, channel } of senderPairs.values()) {
+      try {
+        await this.notifySenderFailure(
+          sender,
+          channel,
+          `the recipient's process rejected it after ${MAX_DELIVERY_ATTEMPTS} attempts`
+        );
+      } catch (err) {
+        dlog.warn(`failed to send sender dead-letter notice for ${sender}`, logger_default.errorData(err));
+      }
+    }
   }
   async deliverToMind(mindName, session, payload, sessionConfig, queueId) {
     if (queueId != null) this.inFlight.add(queueId);
@@ -1130,7 +1164,7 @@ var DeliveryManager = class {
     const details = detailLines.length > 0 ? `${detailLines.join("\n")}
 
 ` : "\n";
-    const { getPrompt } = await import("./prompts-NBO3HRK3.js");
+    const { getPrompt } = await import("./prompts-HNKGCAEY.js");
     const notification = await getPrompt("channel_invite", {
       channel,
       heldLine,

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

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

package/dist/{chunk-AI47FDGL.js → chunk-UO4MZQNO.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getMindManager
-} from "./chunk-VAEZCIJC.js";
+} from "./chunk-23UJGVYP.js";
 import {
   chownMindDir,
   gitExec

package/dist/chunk-UTKUO2KY.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import {
+  MIND_LEVEL_THREAD,
+  localHM,
+  parseMeta,
+  recordNotice
+} from "./chunk-IQ7VNWH6.js";
+import {
+  getPrompt
+} from "./chunk-AP2KQMMW.js";
+import {
+  logger_default
+} from "./chunk-QUSMYGNQ.js";
+import {
+  findMind,
+  getDb
+} from "./chunk-H6X6CKDN.js";
+import {
+  systemEvents
+} from "./chunk-2RNMBXD2.js";
+
+// packages/daemon/src/lib/chat/delivery-notices.ts
+import { and, desc, eq, isNull, sql } from "drizzle-orm";
+var nlog = logger_default.child("delivery-notices");
+var COALESCE_WINDOW_MINUTES = 15;
+var recordChains = /* @__PURE__ */ new Map();
+async function recordDeliveryFailure(input) {
+  const key = `${input.mind}
+${input.channel}`;
+  const next = (recordChains.get(key) ?? Promise.resolve()).then(
+    () => recordDeliveryFailureUnserialized(input)
+  );
+  recordChains.set(key, next);
+  await next;
+  if (recordChains.get(key) === next) recordChains.delete(key);
+}
+async function recordDeliveryFailureUnserialized(input) {
+  const thread = input.thread ?? MIND_LEVEL_THREAD;
+  try {
+    const db = await getDb();
+    const existing = await db.select().from(systemEvents).where(
+      and(
+        eq(systemEvents.mind, input.mind),
+        eq(systemEvents.type, "notice"),
+        eq(systemEvents.delivery, "next-turn"),
+        eq(systemEvents.thread, thread),
+        isNull(systemEvents.delivered_at),
+        // Literal subtype + bound channel value — not string-built SQL.
+        sql`json_extract(${systemEvents.meta}, '$.subtype') = 'delivery_failed'`,
+        sql`json_extract(${systemEvents.meta}, '$.channel') = ${input.channel}`,
+        sql`${systemEvents.created_at} > datetime('now', ${`-${COALESCE_WINDOW_MINUTES} minutes`})`
+      )
+    ).orderBy(desc(systemEvents.id)).limit(1).get();
+    if (existing) {
+      const meta = parseMeta(existing.meta, `event ${existing.id}`);
+      const count = (typeof meta.count === "number" ? meta.count : 1) + 1;
+      const body2 = await getPrompt("delivery_failure_coalesced", {
+        count: String(count),
+        channel: input.channel,
+        since: localHM(existing.created_at),
+        reason: input.reason
+      });
+      await db.update(systemEvents).set({ body: body2, meta: JSON.stringify({ ...meta, count }) }).where(eq(systemEvents.id, existing.id));
+      return;
+    }
+    const body = await getPrompt("delivery_failure_notice", {
+      channel: input.channel,
+      reason: input.reason
+    });
+    await recordNotice({
+      mind: input.mind,
+      thread,
+      kind: "delivery_failed",
+      reason: "delivery_failed",
+      detail: body,
+      meta: { channel: input.channel, count: 1 }
+    });
+  } catch (err) {
+    nlog.warn(
+      `failed to record delivery-failure notice for ${input.mind} \u2192 ${input.channel}`,
+      logger_default.errorData(err)
+    );
+  }
+}
+async function recordSenderDeliveryFailure(sender, channel, reason) {
+  try {
+    const entry = await findMind(sender);
+    if (!entry) return;
+    await recordDeliveryFailure({ mind: entry.parent ?? entry.name, channel, reason });
+  } catch (err) {
+    nlog.warn(
+      `failed to record sender delivery-failure notice for ${sender} \u2192 ${channel}`,
+      logger_default.errorData(err)
+    );
+  }
+}
+
+export {
+  COALESCE_WINDOW_MINUTES,
+  recordDeliveryFailure,
+  recordSenderDeliveryFailure
+};