@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/monitoring/oom-kill-reporter.ts

@@ -0,0 +1,469 @@
+/**
+ * Reports kernel OOM kills in this container as `oom_kill` watchdog events.
+ *
+ * The log comes from `dmesg`, not `/dev/kmsg`: the device is not mounted in
+ * the container, while `dmesg` uses the syslog syscall the container is
+ * allowed. The log is per kernel, not per container. A kill is this
+ * container's when the kernel's `oom-kill:` header names a cgroup carrying
+ * this container's id, which the container learns from its own mount table
+ * since `/proc/self/cgroup` reads `/` inside a cgroup namespace. The kernel
+ * rate-limits that header in a burst, so header-less kills fall back to the
+ * cgroup `memory.events` counter.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { getRawShareAnalytics } from "../platform/consent-cache.js";
+import { recordWatchdogEvent } from "../telemetry/watchdog-events-store.js";
+import { getContainerMemoryEvents } from "../util/cgroup-memory.js";
+import { getLogger } from "../util/logger.js";
+import { DAEMON_OOM_SCORE_ADJ } from "../util/oom-priority.js";
+import { getMonitoringDataDir } from "../util/platform.js";
+import type { ResourceSample } from "./resource-sample-types.js";
+
+const log = getLogger("oom-kill-reporter");
+
+export const OOM_KILL_CHECK_NAME = "oom_kill";
+const CURSOR_FILENAME = "oom-kill-cursor.json";
+/** Cadence for hosts without `memory.events`. */
+const FALLBACK_SCAN_INTERVAL_MS = 60_000;
+/** The detail bag is capped at 4 KiB server-side. */
+const MAX_VICTIMS_IN_DETAIL = 10;
+const DMESG_TIMEOUT_MS = 5_000;
+/** Mounts whose source path the container runtime names after the container. */
+const CONTAINER_ID_MOUNTPOINTS = new Set([
+  "/etc/hosts",
+  "/etc/hostname",
+  "/etc/resolv.conf",
+  "/dev/termination-log",
+]);
+
+export interface KernelLogEntry {
+  /** Seconds since boot, monotonic for the life of the kernel. */
+  time: number;
+  msg: string;
+}
+
+export interface OomKill {
+  time: number;
+  pid: number;
+  comm: string;
+  oomScoreAdj: number | null;
+  anonRssKb: number | null;
+  totalVmKb: number | null;
+  /** Victim's cgroup from the `oom-kill:` header; null when the header was rate-limited away. */
+  memcg: string | null;
+}
+
+type Attribution = "cgroup" | "cgroup_counter" | "kernel_log";
+
+/** `dmesg --json`: `{"dmesg":[{"pri":3,"time":44170.542,"msg":"..."}]}`. */
+export function parseDmesgJson(text: string): KernelLogEntry[] | null {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    const rows = (parsed as { dmesg?: unknown }).dmesg;
+    if (!Array.isArray(rows)) {
+      return null;
+    }
+    const entries: KernelLogEntry[] = [];
+    for (const row of rows) {
+      const { time, msg } = row as { time?: unknown; msg?: unknown };
+      if (typeof time === "number" && typeof msg === "string") {
+        entries.push({ time, msg });
+      }
+    }
+    return entries;
+  } catch {
+    return null;
+  }
+}
+
+/** Plain `dmesg`: `[   44170.542000] message` per line. */
+export function parseDmesgText(text: string): KernelLogEntry[] {
+  const entries: KernelLogEntry[] = [];
+  for (const line of text.split("\n")) {
+    const match = /^\[\s*(\d+\.\d+)\]\s?(.*)$/.exec(line);
+    if (match) {
+      entries.push({ time: parseFloat(match[1]), msg: match[2] });
+    }
+  }
+  return entries;
+}
+
+const OOM_KILL_RE = /[Oo]ut of memory: Killed process (\d+) \(([^)]*)\)(.*)$/;
+const OOM_HEADER_RE = /^oom-kill:.*task_memcg=([^,]*),task=[^,]*,pid=(\d+)/;
+
+function kb(fields: string, key: string): number | null {
+  const match = new RegExp(`${key}:(\\d+)kB`).exec(fields);
+  return match ? parseInt(match[1], 10) : null;
+}
+
+export function oomKillsFromEntries(entries: KernelLogEntry[]): OomKill[] {
+  const sorted = [...entries].sort((a, b) => a.time - b.time);
+  // The header precedes its "Killed process" line and names the same pid.
+  const memcgByPid = new Map<number, string>();
+  const kills: OomKill[] = [];
+  for (const entry of sorted) {
+    const header = OOM_HEADER_RE.exec(entry.msg);
+    if (header) {
+      memcgByPid.set(parseInt(header[2], 10), header[1]);
+      continue;
+    }
+    const kill = OOM_KILL_RE.exec(entry.msg);
+    if (!kill) {
+      continue;
+    }
+    const pid = parseInt(kill[1], 10);
+    const fields = kill[3];
+    const adj = /oom_score_adj:(-?\d+)/.exec(fields);
+    kills.push({
+      time: entry.time,
+      pid,
+      comm: kill[2],
+      oomScoreAdj: adj ? parseInt(adj[1], 10) : null,
+      anonRssKb: kb(fields, "anon-rss"),
+      totalVmKb: kb(fields, "total-vm"),
+      memcg: memcgByPid.get(pid) ?? null,
+    });
+    memcgByPid.delete(pid);
+  }
+  return kills;
+}
+
+/** Null when `dmesg` is absent or lacks CAP_SYSLOG. */
+export async function readKernelLog(): Promise<KernelLogEntry[] | null> {
+  if (process.platform !== "linux") {
+    return null;
+  }
+  const run = async (args: string[]): Promise<string | null> => {
+    try {
+      const proc = Bun.spawn(["dmesg", ...args], {
+        stdout: "pipe",
+        stderr: "ignore",
+        windowsHide: true,
+        timeout: DMESG_TIMEOUT_MS,
+      });
+      const text = await new Response(proc.stdout).text();
+      return (await proc.exited) === 0 ? text : null;
+    } catch {
+      return null;
+    }
+  };
+  const json = await run(["--json"]);
+  const fromJson = json != null ? parseDmesgJson(json) : null;
+  if (fromJson) {
+    return fromJson;
+  }
+  const text = await run([]);
+  return text != null ? parseDmesgText(text) : null;
+}
+
+/**
+ * Container ids from `/proc/self/mountinfo`: the runtime names the source of
+ * the hosts, hostname, resolv.conf and termination-log mounts after the
+ * container (Kata: `<id>-<hash>-hosts`; Docker: `.../containers/<id>/hosts`).
+ */
+export function parseOwnContainerIds(mountinfo: string): Set<string> {
+  const ids = new Set<string>();
+  for (const line of mountinfo.split("\n")) {
+    const fields = line.split(" ");
+    if (fields.length < 5 || !CONTAINER_ID_MOUNTPOINTS.has(fields[4])) {
+      continue;
+    }
+    for (const id of line.match(/[0-9a-f]{64}/g) ?? []) {
+      ids.add(id);
+    }
+  }
+  return ids;
+}
+
+function readOwnContainerIds(): Set<string> {
+  try {
+    return parseOwnContainerIds(readFileSync("/proc/self/mountinfo", "utf-8"));
+  } catch {
+    return new Set();
+  }
+}
+
+function readBootId(): string | null {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+
+interface Cursor {
+  bootId: string | null;
+  lastTime: number;
+}
+
+function readCursor(path: string): Cursor | null {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial<Cursor>;
+    if (typeof parsed.lastTime === "number") {
+      return { bootId: parsed.bootId ?? null, lastTime: parsed.lastTime };
+    }
+  } catch {
+    // Missing or unreadable.
+  }
+  return null;
+}
+
+function writeCursor(path: string, cursor: Cursor): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(cursor));
+}
+
+function memcgIsOurs(memcg: string, ids: ReadonlySet<string>): boolean {
+  for (const id of ids) {
+    if (memcg.includes(id)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export interface OomKillReporterOptions {
+  readKernelLog?: () => Promise<KernelLogEntry[] | null>;
+  /** Cumulative cgroup oom_kill count, read after the log so it covers every logged kill. */
+  readKillCounter?: () => number | null;
+  readOwnContainerIds?: () => ReadonlySet<string>;
+  readBootId?: () => string | null;
+  shareAnalytics?: () => boolean | null;
+  cursorPath?: string;
+  record?: typeof recordWatchdogEvent;
+}
+
+export interface OomKillReport {
+  attribution: Attribution;
+  victims: OomKill[];
+  /** Kills the counter saw that the log could not name. */
+  unnamed: number;
+}
+
+export interface OomKillReporter {
+  /** Returns what was queued, for tests. */
+  check(
+    sample: ResourceSample,
+    now: number,
+    daemonPid: number | null,
+  ): Promise<OomKillReport | null>;
+}
+
+export function createOomKillReporter(
+  options: OomKillReporterOptions = {},
+): OomKillReporter {
+  const read = options.readKernelLog ?? readKernelLog;
+  const readKillCounter =
+    options.readKillCounter ??
+    (() => getContainerMemoryEvents()?.oomKill ?? null);
+  const ownIds = options.readOwnContainerIds ?? readOwnContainerIds;
+  const bootId = options.readBootId ?? readBootId;
+  const shareAnalytics = options.shareAnalytics ?? getRawShareAnalytics;
+  const cursorPath =
+    options.cursorPath ?? join(getMonitoringDataDir(), CURSOR_FILENAME);
+  const record = options.record ?? recordWatchdogEvent;
+
+  let firstScan = true;
+  let lastScanAt = 0;
+  let lastKillCounter: number | null = null;
+  /**
+   * Counter credit with no log line yet: the kernel prints the kill line
+   * before it increments the counter, so a kill between the log read and the
+   * counter read is counted but not yet visible. Credit is spent on the next
+   * scan and reported as unnamed if still unspent, so a kill that never logs
+   * a line cannot claim a neighbour's later.
+   */
+  let owed = 0;
+  /** A scan was skipped mid-way; the next tick scans regardless of the sampler. */
+  let scanDue = false;
+  /** A report the telemetry store refused; retried before the next scan. */
+  let pending: {
+    report: OomKillReport;
+    sample: ResourceSample;
+    daemonPid: number | null;
+    cursor: Cursor;
+  } | null = null;
+
+  const queue = (
+    report: OomKillReport,
+    sample: ResourceSample,
+    daemonPid: number | null,
+    cursor: Cursor,
+  ): boolean => {
+    if (shareAnalytics() === false) {
+      writeCursor(cursorPath, cursor);
+      return true;
+    }
+    const killedDaemon = report.victims.some(
+      (kill) =>
+        kill.oomScoreAdj === DAEMON_OOM_SCORE_ADJ ||
+        (daemonPid != null && kill.pid === daemonPid),
+    );
+    const detail = {
+      attribution: report.attribution,
+      victim_count: report.victims.length + report.unnamed,
+      unnamed_victims: report.unnamed,
+      victims: report.victims.slice(-MAX_VICTIMS_IN_DETAIL).map((kill) => ({
+        pid: kill.pid,
+        comm: kill.comm,
+        oom_score_adj: kill.oomScoreAdj,
+        anon_rss_kb: kill.anonRssKb,
+        total_vm_kb: kill.totalVmKb,
+      })),
+      daemon_pid: daemonPid,
+      killed_daemon: killedDaemon,
+      memory_current_bytes: sample.memory?.currentBytes ?? null,
+      memory_limit_bytes: sample.memory?.limitBytes ?? null,
+      memory_peak_bytes: sample.memory?.peakBytes ?? null,
+    };
+    const queued = record({
+      checkName: OOM_KILL_CHECK_NAME,
+      value: detail.victim_count,
+      detail,
+    });
+    if (!queued) {
+      return false;
+    }
+    writeCursor(cursorPath, cursor);
+    log.warn(detail, "Kernel OOM kill in the assistant container");
+    return true;
+  };
+
+  return {
+    async check(sample, now, daemonPid) {
+      if (pending) {
+        if (
+          !queue(
+            pending.report,
+            pending.sample,
+            pending.daemonPid,
+            pending.cursor,
+          )
+        ) {
+          return null;
+        }
+        pending = null;
+      }
+
+      const sampleDelta = sample.deltas?.events?.oomKill ?? 0;
+      if (
+        !firstScan &&
+        !scanDue &&
+        sampleDelta === 0 &&
+        now - lastScanAt < FALLBACK_SCAN_INTERVAL_MS
+      ) {
+        return null;
+      }
+      scanDue = false;
+
+      const entries = await read();
+      const currentBootId = bootId();
+      if (entries == null) {
+        firstScan = false;
+        lastScanAt = now;
+        lastKillCounter = readKillCounter() ?? lastKillCounter;
+        if (sampleDelta === 0) {
+          return null;
+        }
+        const report: OomKillReport = {
+          attribution: "cgroup_counter",
+          victims: [],
+          unnamed: sampleDelta,
+        };
+        const cursor = { bootId: currentBootId, lastTime: 0 };
+        if (!queue(report, sample, daemonPid, cursor)) {
+          pending = { report, sample, daemonPid, cursor };
+        }
+        return report;
+      }
+
+      // Read after the log so the count covers every line the log holds.
+      const killCounter = readKillCounter();
+      if (killCounter == null && sample.events != null) {
+        // One failed read of a counter that exists: try again next tick
+        // rather than treating every kill on the kernel as ours.
+        scanDue = true;
+        return null;
+      }
+      const isFirstScan = firstScan;
+      firstScan = false;
+      lastScanAt = now;
+      const counterDelta =
+        killCounter != null && lastKillCounter != null
+          ? Math.max(0, killCounter - lastKillCounter)
+          : null;
+      lastKillCounter = killCounter ?? lastKillCounter;
+
+      const all = oomKillsFromEntries(entries);
+      const maxTime = all.length > 0 ? all[all.length - 1].time : 0;
+      const stored = readCursor(cursorPath);
+      // A different boot id, or a log that has not yet reached the stored
+      // timestamp, means the kernel restarted and the cursor is stale.
+      const sameBoot =
+        stored != null &&
+        stored.bootId === currentBootId &&
+        maxTime >= stored.lastTime;
+      const sinceTime = sameBoot ? stored.lastTime : -1;
+      const fresh = all.filter((kill) => kill.time > sinceTime);
+      const cursor: Cursor = {
+        bootId: currentBootId,
+        lastTime: Math.max(sinceTime, maxTime),
+      };
+      const ids = ownIds();
+
+      let report: OomKillReport | null = null;
+      if (counterDelta == null || isFirstScan) {
+        // No counter to lean on: a kill that took the daemon down restarted
+        // this monitor with it, and the new container's counter starts at 0.
+        const ours = fresh.filter(
+          (kill) => kill.memcg == null || memcgIsOurs(kill.memcg, ids),
+        );
+        if (ours.length > 0) {
+          report = { attribution: "kernel_log", victims: ours, unnamed: 0 };
+        }
+        owed = 0;
+      } else {
+        const byHeader = fresh.filter(
+          (kill) => kill.memcg != null && memcgIsOurs(kill.memcg, ids),
+        );
+        const unknown = fresh.filter((kill) => kill.memcg == null);
+        // Header-attributed kills spend counter credit first; what is left
+        // names header-less kills oldest first. Header-less kills beyond the
+        // credit are neighbours', since our counter would have covered ours.
+        const carry = owed;
+        let credit = counterDelta + carry - byHeader.length;
+        const byCounter = unknown.slice(0, Math.max(0, credit));
+        credit = Math.max(0, credit - byCounter.length);
+        owed = Math.min(credit, counterDelta);
+        const unnamed = credit - owed;
+        const victims = [...byHeader, ...byCounter].sort(
+          (a, b) => a.time - b.time,
+        );
+        if (victims.length > 0 || unnamed > 0) {
+          report = {
+            attribution:
+              byCounter.length === 0 && unnamed === 0
+                ? "cgroup"
+                : "cgroup_counter",
+            victims,
+            unnamed,
+          };
+        }
+      }
+
+      if (report == null) {
+        if (!sameBoot || cursor.lastTime !== stored?.lastTime) {
+          writeCursor(cursorPath, cursor);
+        }
+        return null;
+      }
+      if (!queue(report, sample, daemonPid, cursor)) {
+        pending = { report, sample, daemonPid, cursor };
+      }
+      return report;
+    },
+  };
+}

package/src/monitoring/resource-sampler.ts

@@ -46,6 +46,8 @@ import {
 import { readActiveConversations } from "./active-conversations.js";
 import { readDaemonHeartbeat } from "./daemon-heartbeat.js";
 import { topProcessesByFd } from "./file-descriptors.js";
+import { sweepInheritedOomProtection } from "./oom-inheritance-sweep.js";
+import { createOomKillReporter } from "./oom-kill-reporter.js";
 import { getTrackedDataFiles, readFileResidency } from "./page-cache.js";
 import { topProcessesByMemory } from "./process-memory.js";
 import {
@@ -70,6 +72,8 @@ const SNAPSHOTS_DIR = "snapshots";
 const MAX_SNAPSHOTS = 20;
 /** Cap on retained baseline snapshots (4h of history at the 10min default). */
 const MAX_BASELINE_SNAPSHOTS = 24;
+/** How often the daemon's descendants are checked for inherited OOM protection. */
+const OOM_SWEEP_INTERVAL_MS = 5_000;
 
 /** Snapshot kinds: filename prefix + retention are per-kind so periodic
  * baselines can never evict high-memory forensics. */
@@ -264,6 +268,8 @@ export function startResourceSampler(
   // thread's kernel state mid-stall when the heartbeat goes stale.
   const stallCapture = createStallCaptureMonitor(dataDir);
   const processUsage = createProcessUsageTracker();
+  const oomKills = createOomKillReporter();
+  let lastOomSweepAt = 0;
 
   // Skip ticks while a sample is in flight: the disk measurement can take
   // seconds (du over the workspace), and overlapping ticks would all delta
@@ -302,6 +308,30 @@ export function startResourceSampler(
       log.warn({ err }, "Daemon stall check failed");
     }
 
+    try {
+      await oomKills.check(sample, now, readDaemonHeartbeat(now)?.pid ?? null);
+    } catch (err) {
+      log.warn({ err }, "OOM kill report failed");
+    }
+
+    if (now - lastOomSweepAt >= OOM_SWEEP_INTERVAL_MS) {
+      lastOomSweepAt = now;
+      const daemonPid = readDaemonHeartbeat(now)?.pid;
+      if (daemonPid != null) {
+        try {
+          const resets = sweepInheritedOomProtection({
+            daemonPid,
+            keepPids: new Set([process.pid]),
+          });
+          for (const reset of resets) {
+            log.warn(reset, "Reset OOM protection inherited from the daemon");
+          }
+        } catch (err) {
+          log.warn({ err }, "OOM inheritance sweep failed");
+        }
+      }
+    }
+
     const ratio = sample.memory?.ratio;
     if (
       ratio != null &&

package/src/notifications/README.md

@@ -2,17 +2,66 @@
 
 Signal-driven notification architecture where producers emit free-form events and an LLM-backed decision engine determines whether, where, and how to notify the user.
 
+## From me chat alerts
+
+With `assistant-initiated-threads` enabled, an `assistant.share` from a background,
+scheduled, or unresolved source can create a new chat in From me. The pipeline
+resolves that promotion once and applies it only to vellum conversation pairing.
+Ordinary shares retain their authored content and original urgency.
+
+A new chat qualifies for an alert only after its conversation and seed message
+are persisted and it belongs in From me: an assistant-initiated, visible,
+ungrouped chat. Reusing an existing chat, filing it elsewhere, pinning it, or
+failing to persist the seed does not enable this additional alert. An invalid
+reuse target that falls back to a newly created eligible chat does qualify.
+
+The successful creation makes the local intent non-silent. When vellum is
+selected and platform credentials are configured, routing can also add the
+existing mobile push channel. Explicit quiet intent, suppression, exclusive
+channel allowlists, and single-channel routing retain precedence. A platform
+route added solely for this feature is skipped if creation does not qualify;
+independently selected urgent or explicit delivery retains its existing policy.
+
+Both paths target the persisted new conversation and seed message. Replayed
+decisions reuse the original delivery audit and destination without creating
+another chat or seed. Shares retain their existing transcript, Home feed, and
+notification bell behavior; they are not classified as completion signals.
+
+Local delivery waits for the existing bounded platform outcome and preserves
+per-platform remote/local duplicate suppression. Missing tokens, disabled remote
+push, or failed platform delivery leave the local fallback available. Provider
+acceptance does not prove that the OS displayed a banner.
+
+iOS uses the existing APNs route and device registration. macOS uses the live
+native notification bridge while the application is running, including hidden
+or minimized windows; quitting the application ends that live-delivery path.
+Android, other Electron clients, and permitted open browser tabs share these
+channels and receive the same eligible events. Existing notification permission,
+active-conversation suppression, tap navigation, and logout behavior apply.
+Opening From me or reconnecting does not replay historical chats as alerts.
+
 ## Completion alerts
 
 `chat.assistant_reply`, `schedule.result`, and explicitly user-facing
 `activity.complete` signals use the available subset of `vellum` and
 `platform`. A self-hosted assistant can deliver through `vellum` without
 mobile push. `completion-policy.ts` owns local presentation: selected
-completions can banner at medium urgency, unrelated low/medium notifications
-remain silent, and explicitly quiet work stays silent. The broadcaster resolves
-the existing `silent` contract once for the local intent and paired-conversation
+completions can banner at medium urgency, and low/medium notifications without
+a completion or new From me chat remain silent, and explicitly quiet work stays silent. The broadcaster resolves
+the existing `silent` contract for the local intent and paired-conversation
 event; clients continue honoring it.
 
+`notifications.newMessageEnabled` defaults to true. Setting it false makes
+only `chat.assistant_reply` local intents silent and suppresses their platform
+push. Selected channels remain routing candidates throughout awaited broadcast
+preparation, so re-enabling alerts before the send can still deliver a push.
+`chat-reply-policy.ts` reads the current preference immediately before delivery,
+including deferred local sends and each platform retry. Delivery audit rows
+record a suppressed push as skipped; a push already accepted by a provider keeps
+its acceptance metadata. Transcript pairing, unread state, feed policy,
+external-channel delivery, scheduled results, and action-required alerts retain
+their existing behavior.
+
 Local completion delivery requires the active Vellum guardian principal from
 the resolved destination. The broadcaster checks that identity before pairing,
 and the adapter targets the event hub's `targetActorPrincipalId` before sending
@@ -189,7 +238,7 @@ Before an adapter sends a notification, `pairDeliveryWithConversation()` (in `co
 
 - **Vellum (`start_new_conversation`)**:
   - A signal that sets `requiresConversation` gets a conversation of its own, created with its seed message before the send (`standard` unless the producer overrides `conversationType`). An explicit `reuse_existing` action appends to a valid target instead, and falls back to a new conversation (`conversationFallbackUsed: true`) when the target is stale.
-  - A signal that does not set it creates no conversation, except that with `assistant-initiated-threads` on, an `assistant.share` with no `conversationMetadata.source` of its own is promoted to one when its producing conversation is a background or scheduled run, or does not resolve (`withAssistantInitiatedThread()`). Otherwise its body is appended to the conversation that produced it (resolved from `sourceContextId`). A `chat.assistant_reply` appends nothing, because the full reply is already in that transcript.
+  - A signal that does not set it creates no conversation, except that with `assistant-initiated-threads` on, an `assistant.share` with no `conversationMetadata.source` of its own is promoted to one when its producing conversation is a background or scheduled run, or does not resolve (`resolveAssistantInitiatedThread()` in `assistant-initiated-thread.ts`). Otherwise its body is appended to the conversation that produced it (resolved from `sourceContextId`). A `chat.assistant_reply` appends nothing, because the full reply is already in that transcript.
 - **External channels (`continue_existing_conversation`)**: only the chat's home conversation is resolved, and nothing is written. The broadcaster records the delivered post as an assistant row once the channel acknowledges it (`recordDeliveredChannelPost`), so a failed or pending delivery never reads as something the assistant said.
 - **`push_only`** (platform) and **`not_deliverable`**: nothing is paired. Platform push deep-links through the vellum delivery's conversation.
 - **Guardian-request deliveries to channels** pair nothing either: they are projections of a canonical request, and only their vellum delivery carries a conversation (see `notifications/AGENTS.md`).