volute 0.52.0 → 0.54.0

package/templates/_base/home/VOLUTE.md

@@ -53,7 +53,7 @@ Messages are routed to named threads based on rules in `.config/routes.json`. Ea
 
 ## New Channels
 
-When a message arrives from a channel you don't have a routing rule for, it's held rather than delivered — and because you haven't seen it, it isn't recorded in your history or counted as a message you received. You'll get a **[New channel: ...]** note in your main thread with the sender and a preview; it repeats (1st held message, then every 10th) so a channel stays visible. To start hearing it, add a rule for that channel to `.config/routes.json` — the backlog is released (the 10 most recent per channel; older ones stay readable via `volute chat read <channel>`) and recorded as inbound when you actually receive them. To stop the notes and archive the backlog, run `volute chat channels decline <channel>`; `volute chat channels list` shows what's currently held. (To skip gating entirely and route everything to your default thread, set `"gateUnmatched": false`.)
+When a message arrives from a channel you don't have a routing rule for, it's held rather than delivered — and because you haven't seen it, it isn't recorded in your history or counted as a message you received. You'll get a **[New channel: ...]** note in your main thread with the sender and a preview; it repeats (1st held message, then every 10th) so a channel stays visible. To start hearing it, add a rule for that channel to `.config/routes.json` — the backlog is released (the 10 most recent per channel; older ones stay readable via `volute chat channels peek "<channel>"`) and recorded as inbound when you actually receive them. To stop the notes and archive the backlog, run `volute chat channels decline "<channel>"`; `volute chat channels list` shows what's currently held. Quote the channel in these commands — an unquoted `#name` is a shell comment and gets stripped before the CLI sees it. (To skip gating entirely and route everything to your default thread, set `"gateUnmatched": false`.)
 
 ## Variants
 

package/templates/_base/src/lib/codex-session-seed.ts

@@ -0,0 +1,463 @@
+/**
+ * Codex session seeding.
+ *
+ * When a codex mind starts a fresh *persistent* session (no saved thread id —
+ * e.g. after a sleep archived the pointer), we seed the new thread by copying
+ * the tail of the previous session's Codex rollout into a new synthetic rollout
+ * file. The Codex SDK (`codex exec resume <threadId>`) then finds and resumes it
+ * natively, so the mind experiences the conversation continuing rather than
+ * waking into an empty context.
+ *
+ * The rollout is reconstructed selectively, not verbatim:
+ *   - The `session_meta` header is copied with a fresh thread id (`session_id`
+ *     and `id`) and an updated timestamp; `parent_thread_id` is dropped.
+ *   - Body `response_item` lines of type `message` and COMPLETE
+ *     `custom_tool_call`/`custom_tool_call_output` pairs are kept verbatim.
+ *   - `reasoning` items are dropped: their `encrypted_content` is opaque and
+ *     provider-bound, the likeliest thing to poison a resume.
+ *   - `event_msg` (telemetry), `turn_context`, and `world_state` are dropped;
+ *     they carry no conversation content and `turn_context`'s recorded model
+ *     would otherwise trigger a spurious model-mismatch warning on resume.
+ *
+ * Verified against @openai/codex-sdk 0.144.x: `resumeThread` shells out to
+ * `codex exec resume <threadId>`, which locates the rollout by scanning
+ * CODEX_HOME/sessions for a filename containing the thread id, then reconstructs
+ * the conversation from the `response_item` lines. A synthetic rollout with the
+ * dropped line types above (and a tail starting at a user message) loads and
+ * resumes cleanly.
+ *
+ * Nothing here throws: any failure returns null so session start is never blocked.
+ */
+
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { findCodexSessionFile } from "./context-breakdown.js";
+import { log } from "./logger.js";
+import { parseArchiveTimestamp } from "./seed-note.js";
+import { archivePointerTimestamp } from "./session-seed.js";
+
+/** Default seed budget (estimated tokens) when config omits continuity.seedTokens. */
+export const DEFAULT_SEED_TOKENS = 30000;
+
+// Archived pointers are named `<name>-<timestamp>.json`, where the timestamp is
+// `new Date().toISOString().replace(/[:.]/g, "-").slice(0, 16)` → `YYYY-MM-DDTHH-MM`
+// (see archiveSessions in the daemon's sleep-manager). Matching the strict shape
+// after the `<name>-` prefix disambiguates `main-...` from a `main-thread-...`.
+const ARCHIVE_SUFFIX = /^(\d{4}-\d{2}-\d{2}T\d{2}-\d{2})\.json$/;
+
+type RolloutLine = Record<string, unknown> & {
+  type?: string;
+  timestamp?: string;
+  payload?: Record<string, unknown> & {
+    type?: string;
+    role?: string;
+    call_id?: string;
+  };
+};
+
+/** A resolved archive pointer: the previous thread id and when it was archived. */
+export type ArchivedThread = { threadId: string; archivedAt: number | null };
+
+/**
+ * Newest archived codex thread for `<name>` under `<sessionsDir>/archive/`, or
+ * null if there's no matching pointer (or it can't be read). Codex pointer files
+ * hold `{ threadId }` (see the codex template's session-store). `archivedAt` is
+ * the archive timestamp in epoch millis (null if unparseable).
+ */
+export function findLatestArchivedThread(sessionsDir: string, name: string): ArchivedThread | null {
+  const archiveDir = resolve(sessionsDir, "archive");
+  let files: string[];
+  try {
+    files = readdirSync(archiveDir);
+  } catch {
+    return null;
+  }
+
+  const prefix = `${name}-`;
+  let bestTs = "";
+  let bestFile: string | null = null;
+  for (const file of files) {
+    if (!file.startsWith(prefix)) continue;
+    const match = file.slice(prefix.length).match(ARCHIVE_SUFFIX);
+    if (!match) continue;
+    // Timestamps are zero-padded ISO, so lexicographic comparison is chronological.
+    if (match[1] > bestTs) {
+      bestTs = match[1];
+      bestFile = file;
+    }
+  }
+  if (!bestFile) return null;
+
+  try {
+    const data = JSON.parse(readFileSync(resolve(archiveDir, bestFile), "utf-8"));
+    if (typeof data.threadId !== "string") return null;
+    return { threadId: data.threadId, archivedAt: parseArchiveTimestamp(bestTs) };
+  } catch {
+    return null;
+  }
+}
+
+/** Estimate tokens for a raw JSONL line as its JSON text length / 4. */
+function estimateTokens(raw: string): number {
+  return raw.length / 4;
+}
+
+/** A turn starts at a user `message` response_item (the incoming prompt). */
+function isTurnBoundary(o: RolloutLine): boolean {
+  return o.payload?.type === "message" && o.payload?.role === "user";
+}
+
+/** Response-item payload types that carry conversation content we keep. */
+function isKeptBody(o: RolloutLine): boolean {
+  if (o.type !== "response_item") return false;
+  const pt = o.payload?.type;
+  return pt === "message" || pt === "custom_tool_call" || pt === "custom_tool_call_output";
+}
+
+/**
+ * Generate a UUIDv7 thread id, matching the shape Codex uses (`019f…`): a 48-bit
+ * millisecond timestamp prefix plus randomness. The value only needs to be a
+ * valid, unique id embedded in the rollout filename and `session_meta`.
+ */
+export function generateThreadId(now: Date = new Date()): string {
+  const bytes = new Uint8Array(16);
+  const ms = BigInt(now.getTime());
+  for (let i = 0; i < 6; i++) {
+    bytes[i] = Number((ms >> BigInt(40 - i * 8)) & 0xffn);
+  }
+  const rand = randomBytes(10);
+  for (let i = 0; i < 10; i++) bytes[6 + i] = rand[i];
+  bytes[6] = (bytes[6] & 0x0f) | 0x70; // version 7
+  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+export type SeededRollout = { threadId: string; lines: string[] };
+
+/** A kept body line paired with its raw JSON text (for token estimation). */
+type KeptLine = { obj: RolloutLine; raw: string };
+
+/** The session_meta header plus the response_items we keep (messages + tool pairs). */
+type ParsedRollout = { meta: RolloutLine; kept: KeptLine[] };
+
+/**
+ * Parse a rollout into its session_meta header and the kept body lines. In strict
+ * mode a corrupt body line aborts (returns null — a broken line means we can't
+ * faithfully reconstruct). In lenient mode corrupt lines are skipped (used when
+ * reading a live rollout that may still be mid-write, e.g. computing the cut point
+ * while Codex is streaming). Returns null if the first line isn't session_meta.
+ */
+function parseRollout(jsonl: string, lenient: boolean): ParsedRollout | null {
+  const rawLines = jsonl.split("\n").filter((l) => l.trim().length > 0);
+  if (rawLines.length === 0) return null;
+
+  let meta: RolloutLine;
+  try {
+    meta = JSON.parse(rawLines[0]);
+  } catch {
+    return null;
+  }
+  if (meta.type !== "session_meta" || typeof meta.payload !== "object" || meta.payload === null) {
+    return null;
+  }
+
+  const kept: KeptLine[] = [];
+  for (let i = 1; i < rawLines.length; i++) {
+    let obj: RolloutLine;
+    try {
+      obj = JSON.parse(rawLines[i]);
+    } catch {
+      if (lenient) continue;
+      return null;
+    }
+    if (isKeptBody(obj)) kept.push({ obj, raw: rawLines[i] });
+  }
+  return { meta, kept };
+}
+
+/** Indices (into kept) of the user-message turn boundaries. */
+function keptBoundaries(kept: KeptLine[]): number[] {
+  const boundaries: number[] = [];
+  for (let i = 0; i < kept.length; i++) {
+    if (isTurnBoundary(kept[i].obj)) boundaries.push(i);
+  }
+  return boundaries;
+}
+
+/**
+ * Choose the first-kept boundary index: walk backward from the final turn, taking
+ * as many whole turns as fit in `seedTokens` (always at least the final turn even
+ * if it alone exceeds the budget). Assumes at least one boundary exists.
+ */
+function tailStartByBudget(kept: KeptLine[], seedTokens: number): number {
+  const boundaries = keptBoundaries(kept);
+  // Turn t spans kept[boundaries[t], boundaries[t+1]); the last turn runs to end.
+  const turnTokens = (t: number): number => {
+    const start = boundaries[t];
+    const end = t + 1 < boundaries.length ? boundaries[t + 1] : kept.length;
+    let sum = 0;
+    for (let i = start; i < end; i++) sum += estimateTokens(kept[i].raw);
+    return sum;
+  };
+  const last = boundaries.length - 1;
+  let startTurn = last;
+  let accum = turnTokens(last);
+  for (let t = last - 1; t >= 0; t--) {
+    const cost = turnTokens(t);
+    if (accum + cost > seedTokens) break;
+    accum += cost;
+    startTurn = t;
+  }
+  return boundaries[startTurn];
+}
+
+/**
+ * Emit the seeded rollout: rewrite the header to `threadId`/`now` (detached from
+ * its parent), then the tail from `startIdx` to end, dropping any tool call/output
+ * whose partner isn't in the tail. Returns null if the tail ends up empty.
+ */
+function emitFromKept(
+  meta: RolloutLine,
+  kept: KeptLine[],
+  startIdx: number,
+  threadId: string,
+  now: Date,
+): SeededRollout | null {
+  // Rewrite the header: fresh thread id and timestamp, detached from its parent.
+  const iso = now.toISOString();
+  const mp = meta.payload as Record<string, unknown>;
+  mp.session_id = threadId;
+  mp.id = threadId;
+  delete mp.parent_thread_id;
+  mp.timestamp = iso;
+  meta.timestamp = iso;
+
+  let tail = kept.slice(startIdx);
+
+  // Keep only tool calls/outputs whose call_id has BOTH a call and an output in
+  // the tail — never an orphaned call (e.g. a truncated final turn) or output.
+  const callIds = new Set<string>();
+  const outputIds = new Set<string>();
+  for (const { obj } of tail) {
+    const p = obj.payload;
+    if (typeof p?.call_id !== "string") continue;
+    if (p.type === "custom_tool_call") callIds.add(p.call_id);
+    else if (p.type === "custom_tool_call_output") outputIds.add(p.call_id);
+  }
+  tail = tail.filter(({ obj }) => {
+    const p = obj.payload;
+    if (p?.type === "custom_tool_call" || p?.type === "custom_tool_call_output") {
+      return typeof p.call_id === "string" && callIds.has(p.call_id) && outputIds.has(p.call_id);
+    }
+    return true;
+  });
+  if (tail.length === 0) return null;
+
+  const lines = [JSON.stringify(meta), ...tail.map((t) => JSON.stringify(t.obj))];
+  return { threadId, lines };
+}
+
+/**
+ * Build the seeded rollout from a previous rollout's raw jsonl text: rewrite the
+ * `session_meta` header to `threadId` with an updated timestamp, then take as
+ * many whole trailing turns as fit in `seedTokens` (always at least the final
+ * turn), keeping message and complete tool-call pairs. Returns null if there's
+ * nothing seedable (empty, no session_meta, no genuine turn, or a corrupt line).
+ */
+export function buildSeededRollout(
+  jsonl: string,
+  threadId: string,
+  seedTokens: number,
+  now: Date = new Date(),
+): SeededRollout | null {
+  const p = parseRollout(jsonl, false);
+  if (!p || p.kept.length === 0) return null;
+  if (keptBoundaries(p.kept).length === 0) return null;
+  return emitFromKept(p.meta, p.kept, tailStartByBudget(p.kept, seedTokens), threadId, now);
+}
+
+/**
+ * A pinned cut point for rotation. Codex `response_item` message lines carry no
+ * stable id, so we pin the boundary by its top-level `timestamp` (millisecond
+ * precision — unique in practice). Rotation locates the same turn by matching it.
+ */
+export type CodexSeedCut = { boundaryTimestamp: string };
+
+/**
+ * Compute the cut point (the first-kept turn's timestamp) for a `seedTokens` budget,
+ * from raw jsonl. Parsed leniently because the live rollout may still be mid-write
+ * when this runs at warn time. Returns null if there's no genuine turn or the chosen
+ * boundary lacks a timestamp to pin on.
+ */
+export function computeCodexSeedCut(jsonl: string, seedTokens: number): CodexSeedCut | null {
+  const p = parseRollout(jsonl, true);
+  if (!p || p.kept.length === 0) return null;
+  if (keptBoundaries(p.kept).length === 0) return null;
+  const boundary = p.kept[tailStartByBudget(p.kept, seedTokens)].obj;
+  if (typeof boundary.timestamp !== "string") return null;
+  return { boundaryTimestamp: boundary.timestamp };
+}
+
+/**
+ * Build the seeded rollout starting at a pinned boundary timestamp (the whole tail
+ * from that turn through EOF). Used by rotation to honor the cut point the mind was
+ * warned about, regardless of how much the rollout grew after the warning. Returns
+ * null if the boundary isn't found or a line is corrupt.
+ */
+export function buildSeededRolloutFromCut(
+  jsonl: string,
+  threadId: string,
+  boundaryTimestamp: string,
+  now: Date = new Date(),
+): SeededRollout | null {
+  const p = parseRollout(jsonl, false);
+  if (!p || p.kept.length === 0) return null;
+  const startIdx = p.kept.findIndex(
+    (k) => isTurnBoundary(k.obj) && k.obj.timestamp === boundaryTimestamp,
+  );
+  if (startIdx < 0) return null;
+  return emitFromKept(p.meta, p.kept, startIdx, threadId, now);
+}
+
+/** Two-digit zero-padded string for date/time components. */
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+/** Result of a successful codex seed: the new thread id and when the source was archived. */
+export type SeededThreadOutcome = { threadId: string; archivedAt: number | null };
+
+/**
+ * Seed a fresh persistent codex session from the mind's previous archived
+ * rollout. Writes the synthetic rollout under `.mind/codex/sessions/YYYY/MM/DD/`
+ * (matching the real Codex layout) and returns the new thread id plus the
+ * archived-at time (for the gap note), or null if there's nothing to seed. Never
+ * throws — any failure returns null so session start is never blocked.
+ */
+export function seedCodexSession(opts: {
+  mindDir: string;
+  name: string;
+  seedTokens: number;
+  now?: Date;
+}): SeededThreadOutcome | null {
+  const { mindDir, name, seedTokens } = opts;
+  const now = opts.now ?? new Date();
+  // Ephemeral `new-*` sessions are never persisted or archived, so they never
+  // seed. The agent caller already gates on this; guard here too.
+  if (name.startsWith("new-")) return null;
+  if (seedTokens <= 0) return null; // seeding disabled
+
+  try {
+    const sessionsDir = resolve(mindDir, ".mind", "codex-sessions");
+    const archived = findLatestArchivedThread(sessionsDir, name);
+    if (!archived) return null;
+    const oldThreadId = archived.threadId;
+
+    const sourcePath = findCodexSessionFile(oldThreadId, mindDir);
+    if (!sourcePath) return null; // rollout didn't survive archival — start clean
+
+    const threadId = generateThreadId(now);
+    const seeded = buildSeededRollout(readFileSync(sourcePath, "utf-8"), threadId, seedTokens, now);
+    if (!seeded) return null;
+
+    writeSeededRollout(sourcePath, seeded, now);
+    log(
+      "mind",
+      `session "${name}": seeded ${seeded.lines.length} line(s) from ${oldThreadId} → ${threadId}`,
+    );
+    return { threadId, archivedAt: archived.archivedAt };
+  } catch (err) {
+    log("mind", `session "${name}": codex seeding failed, starting fresh:`, err);
+    return null;
+  }
+}
+
+/**
+ * Write a seeded rollout next to its source: into the SAME sessions root the source
+ * rollout was found in, so it lands wherever Codex will look on resume — that root is
+ * CODEX_HOME/sessions (`.mind/codex/sessions` when CODEX_HOME is set) or ~/.codex/sessions
+ * otherwise. `sourcePath` is `<sessionsRoot>/YYYY/MM/DD/rollout-*.jsonl`; climb three
+ * levels. Rollouts live under a local-time YYYY/MM/DD tree with a local-time filename
+ * timestamp, mirroring how Codex itself names them.
+ */
+function writeSeededRollout(sourcePath: string, seeded: SeededRollout, now: Date): void {
+  const sessionsRoot = resolve(dirname(sourcePath), "..", "..", "..");
+  const y = String(now.getFullYear());
+  const mo = pad2(now.getMonth() + 1);
+  const d = pad2(now.getDate());
+  const fnTs = `${y}-${mo}-${d}T${pad2(now.getHours())}-${pad2(now.getMinutes())}-${pad2(now.getSeconds())}`;
+  const destDir = resolve(sessionsRoot, y, mo, d);
+  mkdirSync(destDir, { recursive: true });
+  writeFileSync(
+    resolve(destDir, `rollout-${fnTs}-${seeded.threadId}.jsonl`),
+    `${seeded.lines.join("\n")}\n`,
+  );
+}
+
+/**
+ * Write an archive pointer for a rotated-out codex thread, matching how sleep archival
+ * preserves the live pointer: `<sessionsDir>/archive/<name>-<UTC-ts>.json` holding
+ * `{ threadId }` (the codex session-store format). Reuses the shared timestamp format
+ * (archivePointerTimestamp) so the byte layout matches sleep-manager's codex branch and
+ * findLatestArchivedThread keeps finding it.
+ */
+export function writeCodexRotationArchivePointer(
+  sessionsDir: string,
+  name: string,
+  threadId: string,
+  now: Date = new Date(),
+): void {
+  const archiveDir = resolve(sessionsDir, "archive");
+  mkdirSync(archiveDir, { recursive: true });
+  const dest = resolve(archiveDir, `${name}-${archivePointerTimestamp(now)}.json`);
+  writeFileSync(dest, JSON.stringify({ threadId }));
+}
+
+/**
+ * Rotate a codex session in place at the context limit. Reads the live rollout, builds
+ * a seeded tail from the pinned `cut` (falling back to a budget-based tail when the pin
+ * can't be honored), writes it as a new synthetic rollout next to the source, and — for
+ * persistent sessions — archives the rotated-out thread pointer so the full transcript
+ * stays findable. Returns the new thread id, or null if rotation can't proceed (the
+ * caller then leaves the old thread in place). Never throws.
+ */
+export function rotateCodexSession(opts: {
+  mindDir: string;
+  name: string;
+  oldThreadId: string;
+  cut: CodexSeedCut | null;
+  seedTokens: number;
+  now?: Date;
+}): string | null {
+  const { mindDir, name, oldThreadId, cut, seedTokens } = opts;
+  const now = opts.now ?? new Date();
+  try {
+    const sourcePath = findCodexSessionFile(oldThreadId, mindDir);
+    if (!sourcePath) return null; // live rollout not found — leave the old thread
+    const jsonl = readFileSync(sourcePath, "utf-8");
+    const threadId = generateThreadId(now);
+    // Honor the pinned boundary the mind was warned about; only fall back to a
+    // budget-based tail if the pin can't be resolved (missing/renamed boundary).
+    const seeded =
+      (cut ? buildSeededRolloutFromCut(jsonl, threadId, cut.boundaryTimestamp, now) : null) ??
+      buildSeededRollout(jsonl, threadId, seedTokens, now);
+    if (!seeded) return null;
+
+    writeSeededRollout(sourcePath, seeded, now);
+    // Ephemeral `new-*` sessions rotate too, but leave no pointer/archive behind.
+    if (!name.startsWith("new-")) {
+      const sessionsDir = resolve(mindDir, ".mind", "codex-sessions");
+      writeCodexRotationArchivePointer(sessionsDir, name, oldThreadId, now);
+    }
+    log(
+      "mind",
+      `session "${name}": rotated ${oldThreadId} → ${threadId} (${seeded.lines.length} lines)`,
+    );
+    return threadId;
+  } catch (err) {
+    log("mind", `session "${name}": rotation failed:`, err);
+    return null;
+  }
+}

package/templates/_base/src/lib/context-breakdown.ts

@@ -451,9 +451,17 @@ export async function processPiSession(
 
 // --- Preamble text readers ---
 
-/** Read the SDK instruction file content (CLAUDE.md, MINDS.md, or AGENTS.md). */
+/**
+ * Read the instruction file the runtime loads on its own (CLAUDE.md for the
+ * Claude Agent SDK, AGENTS.md for codex).
+ *
+ * MINDS.md is deliberately absent: pi does not auto-load it, so the pi template
+ * appends it to the system prompt instead (see pi's `withMechanicsDoc`). Listing
+ * it here would count those tokens twice — once under `systemPrompt` and again
+ * under `sdkInstructions`.
+ */
 export function readSdkInstructions(cwd: string): string {
-  for (const name of ["CLAUDE.md", "MINDS.md", "AGENTS.md"]) {
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
     try {
       return readFileSync(resolve(cwd, name), "utf-8");
     } catch (err: any) {
@@ -497,7 +505,7 @@ export function countSystemPromptTokens(systemPrompt: string): number {
   return countTokens(systemPrompt);
 }
 
-/** Count tokens in the SDK instruction file (CLAUDE.md, MINDS.md, or AGENTS.md). */
+/** Count tokens in the runtime-loaded instruction file (CLAUDE.md or AGENTS.md). */
 export function countSdkInstructionTokens(cwd: string): number {
   const content = readSdkInstructions(cwd);
   return content ? countTokens(content) : 0;

package/templates/_base/src/lib/daemon-client.ts

@@ -124,6 +124,41 @@ export async function daemonEmit(event: DaemonEvent): Promise<void> {
   }
 }
 
+/**
+ * Record a notice with the daemon — it reaches the mind through the next-turn
+ * notices drain (the pre-prompt hook). Use for failures the daemon can't see
+ * itself, like context loss inside the mind process. `thread` scopes the notice
+ * to one thread's drain; omitted, any thread's next turn picks it up.
+ * Best-effort: logs on failure, never throws.
+ */
+export async function daemonNotice(input: {
+  kind: string;
+  message: string;
+  thread?: string;
+}): Promise<void> {
+  if (!port || !mind) {
+    console.error("[volute] daemonNotice: VOLUTE_DAEMON_PORT or VOLUTE_MIND not set");
+    return;
+  }
+  try {
+    const res = await fetch(
+      `http://127.0.0.1:${port}/api/minds/${encodeURIComponent(mind)}/notices`,
+      {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(input),
+      },
+    );
+    if (!res.ok) {
+      console.error(
+        `[volute] daemonNotice failed: ${res.status} ${await res.text().catch(() => "")}`,
+      );
+    }
+  } catch (err) {
+    console.error("[volute] daemonNotice request errored:", err);
+  }
+}
+
 export async function daemonSendFile(
   targetMind: string,
   filePath: string,