volute 0.52.0 → 0.54.0

package/dist/{accept-5NK5XJB5.js → accept-RSDIVJL6.js}

@@ -35,6 +35,9 @@ var cmd = command({
     }
     const data = await res.json();
     console.log(`File accepted: ${data.destPath}`);
+    if (data.notified === false) {
+      console.log("Note: the sender could not be notified \u2014 mention it to them directly.");
+    }
   }
 });
 var run = cmd.execute;

package/dist/auto-upgrade-HEVZKPTF.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import {
+  autoUpgradeOne,
+  getUpgradeBlocked,
+  pruneBlocked,
+  runAutoUpgrades,
+  selectEligible
+} from "./chunk-OT5SXF7L.js";
+import "./chunk-CV6BNGFK.js";
+import "./chunk-HTRSSOHY.js";
+import "./chunk-OGPVJ53N.js";
+import "./chunk-LGXVGIWN.js";
+import "./chunk-RGHF3OK5.js";
+import "./chunk-X67BDDZR.js";
+import "./chunk-444RR3YF.js";
+import "./chunk-VDUCLVZI.js";
+import "./chunk-WHL6PKYP.js";
+import "./chunk-YSRYCS3N.js";
+import "./chunk-56IT2ZXF.js";
+import "./chunk-PPSN2MLC.js";
+import "./chunk-7LT3YZUR.js";
+import "./chunk-HKGYZVWN.js";
+import "./chunk-LNNI3MS4.js";
+import "./chunk-OAYY3WF3.js";
+import "./chunk-5Y54AE3L.js";
+import "./chunk-TPX6E6PL.js";
+import "./chunk-UFTDRTCP.js";
+import "./chunk-U54PJPTB.js";
+import "./chunk-ICXY54ZC.js";
+import "./chunk-DW4TRDOZ.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-OIOW3FPT.js";
+import "./chunk-GLM7TVWP.js";
+import "./chunk-EGV6R6UF.js";
+import "./chunk-QUSMYGNQ.js";
+import "./chunk-LGNUFVMR.js";
+import "./chunk-H6X6CKDN.js";
+import "./chunk-2RNMBXD2.js";
+import "./chunk-K3NQKI34.js";
+export {
+  autoUpgradeOne,
+  getUpgradeBlocked,
+  pruneBlocked,
+  runAutoUpgrades,
+  selectEligible
+};

package/dist/{backup-YVGV2ZNM.js → backup-QRNX6RK7.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   stopDaemon
-} from "./chunk-5N32EN4O.js";
+} from "./chunk-Z4Q6TQWL.js";
 import {
-  promptLine,
-  promptPassword
-} from "./chunk-VHWGEJ4V.js";
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
 import {
   daemonFetch
 } from "./chunk-M74I3HHF.js";
 import {
-  getClient,
-  urlOf
-} from "./chunk-LOPXTW6H.js";
+  promptLine,
+  promptPassword
+} from "./chunk-VHWGEJ4V.js";
 import {
   command,
   subcommands
@@ -23,18 +23,18 @@ import {
   RESTIC_INSTALL_HINT,
   resticVersion,
   restoreStagedDb
-} from "./chunk-EDR47UE2.js";
+} from "./chunk-OYF25B62.js";
 import {
   getServiceMode,
   modeLabel,
   stopService
-} from "./chunk-6NLW72HP.js";
+} from "./chunk-CKPAVQNK.js";
 import {
   chownMindDir,
   exec,
   execInherit,
   wrapForIsolation
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import "./chunk-QUSMYGNQ.js";
 import {
   _resetConfigCache,

package/dist/channels-CKCY64TD.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import {
+  resolveMindName
+} from "./chunk-BTY4WNFE.js";
+import {
+  daemonFetch
+} from "./chunk-M74I3HHF.js";
+import {
+  command,
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-FNJCBRD3.js";
+import {
+  formatSuggestions
+} from "./chunk-VDUCLVZI.js";
+import "./chunk-WHL6PKYP.js";
+import "./chunk-YSRYCS3N.js";
+import "./chunk-56IT2ZXF.js";
+import "./chunk-7LT3YZUR.js";
+import "./chunk-HKGYZVWN.js";
+import "./chunk-LNNI3MS4.js";
+import "./chunk-OAYY3WF3.js";
+import "./chunk-5Y54AE3L.js";
+import "./chunk-TPX6E6PL.js";
+import "./chunk-UFTDRTCP.js";
+import "./chunk-U54PJPTB.js";
+import "./chunk-ICXY54ZC.js";
+import "./chunk-DW4TRDOZ.js";
+import "./chunk-WCFSBH33.js";
+import "./chunk-OIOW3FPT.js";
+import "./chunk-GLM7TVWP.js";
+import "./chunk-EGV6R6UF.js";
+import "./chunk-QUSMYGNQ.js";
+import "./chunk-LGNUFVMR.js";
+import "./chunk-H6X6CKDN.js";
+import "./chunk-2RNMBXD2.js";
+import "./chunk-K3NQKI34.js";
+
+// packages/cli/src/commands/chat/channels.ts
+var channelsListCmd = command({
+  name: "volute chat channels",
+  description: "List unrouted (gated) channels holding messages",
+  args: [],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ flags }) => {
+    const mind = resolveMindName(flags);
+    const res = await daemonFetch(`/api/minds/${encodeURIComponent(mind)}/delivery/pending`);
+    if (!res.ok) {
+      const data = await res.json().catch(() => ({}));
+      console.error(data.error ?? `Failed to list gated channels: ${res.status}`);
+      process.exit(1);
+    }
+    const pending = await res.json();
+    if (pending.length === 0) {
+      console.log("No unrouted channels holding messages.");
+      return;
+    }
+    const chW = Math.max(7, ...pending.map((p) => (p.channel ?? "unknown").length));
+    console.log(`${"CHANNEL".padEnd(chW)}  HELD  SINCE`);
+    for (const p of pending) {
+      console.log(
+        `${(p.channel ?? "unknown").padEnd(chW)}  ${String(p.count).padStart(4)}  ${p.firstSeen}`
+      );
+    }
+    console.log(
+      `
+Quote the channel \u2014 an unquoted #name is a comment to the shell.
+  volute chat channels peek "<channel>"     read what's held
+  volute chat channels accept "<channel>"   start hearing it
+  volute chat channels decline "<channel>"  opt out`
+    );
+  }
+});
+var channelsDeclineCmd = command({
+  name: "volute chat channels decline",
+  description: "Decline an unrouted channel: stop invites and archive its held backlog",
+  args: [{ name: "channel", required: true, description: 'Channel to decline (e.g. "#bardo")' }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mind = resolveMindName(flags);
+    const channel = args.channel;
+    const res = await daemonFetch(`/api/minds/${encodeURIComponent(mind)}/gates/decline`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channel })
+    });
+    if (!res.ok) {
+      const data2 = await res.json().catch(() => ({}));
+      console.error(data2.error ?? `Failed to decline channel: ${res.status}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    console.log(`Declined ${channel}; archived ${data.archived} held message(s).`);
+  }
+});
+var channelsAcceptCmd = command({
+  name: "volute chat channels accept",
+  description: "Accept an unrouted channel: add a routing rule and deliver its held backlog",
+  args: [{ name: "channel", required: true, description: 'Channel to accept (e.g. "#bardo")' }],
+  flags: {
+    mind: { type: "string", description: "Mind name" },
+    thread: { type: "string", description: "Thread to route it to (default: one per channel)" }
+  },
+  run: async ({ args, flags }) => {
+    const mind = resolveMindName(flags);
+    const channel = args.channel;
+    const res = await daemonFetch(`/api/minds/${encodeURIComponent(mind)}/gates/accept`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channel, thread: flags.thread })
+    });
+    if (!res.ok) {
+      const data2 = await res.json().catch(() => ({}));
+      console.error(data2.error ?? `Failed to accept channel: ${res.status}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    const note = data.ruleAdded ? "" : " (rule already existed)";
+    console.log(
+      `Accepted ${channel} \u2192 thread ${data.thread}${note}; released ${data.released} held message(s).`
+    );
+    if (!data.known) {
+      console.log(
+        `Note: no channel named ${channel} is known here and nothing was held for it. The rule will route future messages if the name is right \u2014 check it against 'volute chat channels list'.`
+      );
+    }
+    if (data.archived > 0) {
+      console.log(
+        `${data.archived} older message(s) were not delivered \u2014 read them with 'volute chat channels peek "${channel}"'.`
+      );
+    }
+  }
+});
+var channelsPeekCmd = command({
+  name: "volute chat channels peek",
+  description: "Read the messages held on an unrouted channel without accepting it",
+  args: [{ name: "channel", required: true, description: 'Channel to peek at (e.g. "#bardo")' }],
+  flags: {
+    mind: { type: "string", description: "Mind name" }
+  },
+  run: async ({ args, flags }) => {
+    const mind = resolveMindName(flags);
+    const channel = args.channel;
+    const res = await daemonFetch(
+      `/api/minds/${encodeURIComponent(mind)}/gates/peek?channel=${encodeURIComponent(channel)}`
+    );
+    if (!res.ok) {
+      const data2 = await res.json().catch(() => ({}));
+      console.error(data2.error ?? `Failed to read held messages: ${res.status}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    if (data.count === 0) {
+      console.log(`No held messages on ${channel}.`);
+      if (data.suggestions?.length) {
+        console.log(
+          `No channel by that name exists \u2014 did you mean ${formatSuggestions(data.suggestions)}?`
+        );
+      }
+      return;
+    }
+    if (data.shown < data.count) {
+      console.log(`Showing the ${data.shown} most recent of ${data.count} held message(s).
+`);
+    }
+    for (const m of data.messages) {
+      const mark = m.status === "archived" ? " (archived)" : "";
+      console.log(`[${m.createdAt}] ${m.sender ?? "unknown"}${mark}: ${m.content}`);
+    }
+  }
+});
+var cmd = subcommands({
+  name: "volute chat channels",
+  description: "Manage unrouted (gated) channels",
+  commands: {
+    list: {
+      description: "List unrouted channels holding messages",
+      run: channelsListCmd.execute
+    },
+    peek: {
+      description: "Read messages held on an unrouted channel",
+      run: channelsPeekCmd.execute
+    },
+    accept: {
+      description: "Accept an unrouted channel and deliver its held backlog",
+      run: channelsAcceptCmd.execute
+    },
+    decline: {
+      description: "Decline an unrouted channel",
+      run: channelsDeclineCmd.execute
+    }
+  },
+  footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/{chat-VAZ25KVT.js → chat-ZUGNL5GS.js}

@@ -12,7 +12,7 @@ var cmd = subcommands({
   commands: {
     send: {
       description: "Send a message",
-      run: (args) => import("./send-2YKOZJJ5.js").then((m) => m.run(args))
+      run: (args) => import("./send-UXUQKO4N.js").then((m) => m.run(args))
     },
     list: {
       description: "List conversations",
@@ -32,19 +32,19 @@ var cmd = subcommands({
     },
     channels: {
       description: "Manage unrouted (gated) channels",
-      run: (args) => import("./channels-FSAHOQWI.js").then((m) => m.run(args))
+      run: (args) => import("./channels-CKCY64TD.js").then((m) => m.run(args))
     },
     files: {
       description: "List pending incoming files",
-      run: (args) => import("./files-BRY5RRIM.js").then((m) => m.run(args))
+      run: (args) => import("./files-PCKBQHAY.js").then((m) => m.run(args))
     },
     accept: {
       description: "Accept a pending file",
-      run: (args) => import("./accept-5NK5XJB5.js").then((m) => m.run(args))
+      run: (args) => import("./accept-RSDIVJL6.js").then((m) => m.run(args))
     },
     reject: {
       description: "Reject a pending file",
-      run: (args) => import("./reject-TWB4QJHG.js").then((m) => m.run(args))
+      run: (args) => import("./reject-4NFLXKRN.js").then((m) => m.run(args))
     }
   },
   footer: "Use --mind <name> or VOLUTE_MIND to identify the mind."

package/dist/chunk-3LHUXY3E.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import {
+  MIND_LEVEL_THREAD,
+  localHM,
+  parseMeta,
+  recordNotice
+} from "./chunk-HKGYZVWN.js";
+import {
+  getPrompt
+} from "./chunk-OAYY3WF3.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
+};

package/dist/{chunk-SW2U6HRB.js → chunk-444RR3YF.js}

@@ -6,10 +6,15 @@ import {
   getMindToken,
   loadJsonMap,
   saveJsonMapAsync
-} from "./chunk-724DVYHU.js";
+} from "./chunk-WHL6PKYP.js";
 import {
-  deliverEvent
-} from "./chunk-AXFLY5GU.js";
+  MIND_LEVEL_THREAD,
+  deliverEvent,
+  recordNotice
+} from "./chunk-HKGYZVWN.js";
+import {
+  getPrompt
+} from "./chunk-OAYY3WF3.js";
 import {
   isSandboxEnabled,
   wrapForSandbox
@@ -20,7 +25,7 @@ import {
 } from "./chunk-WCFSBH33.js";
 import {
   exec
-} from "./chunk-M77B73VV.js";
+} from "./chunk-OIOW3FPT.js";
 import {
   loadMergedEnv
 } from "./chunk-GLM7TVWP.js";
@@ -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) {