svamp-cli 0.2.356 → 0.2.358

package/dist/friendlyName-B-OEwt0t.mjs

@@ -0,0 +1,341 @@
+import { randomBytes } from 'node:crypto';
+
+const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const LOWER_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+function shortId(length = 10, alphabet = ALPHABET) {
+  const maxUnbiased = Math.floor(256 / alphabet.length) * alphabet.length;
+  let out = "";
+  while (out.length < length) {
+    const buf = randomBytes(length - out.length);
+    for (let i = 0; i < buf.length && out.length < length; i++) {
+      const b = buf[i];
+      if (b < maxUnbiased) out += alphabet[b % alphabet.length];
+    }
+  }
+  return out;
+}
+
+const ADJECTIVES = [
+  "able",
+  "amber",
+  "amused",
+  "ancient",
+  "arctic",
+  "autumn",
+  "azure",
+  "blithe",
+  "bold",
+  "brave",
+  "breezy",
+  "bright",
+  "brisk",
+  "calm",
+  "candid",
+  "cheery",
+  "chill",
+  "clever",
+  "cobalt",
+  "cosmic",
+  "cozy",
+  "crimson",
+  "crisp",
+  "curious",
+  "dapper",
+  "daring",
+  "dawn",
+  "deft",
+  "dewy",
+  "eager",
+  "early",
+  "easy",
+  "electric",
+  "fancy",
+  "feisty",
+  "fleet",
+  "fond",
+  "frosty",
+  "gallant",
+  "gentle",
+  "giddy",
+  "glad",
+  "gleaming",
+  "golden",
+  "graceful",
+  "grand",
+  "hardy",
+  "hazel",
+  "hearty",
+  "honest",
+  "humble",
+  "jolly",
+  "jovial",
+  "keen",
+  "kind",
+  "lively",
+  "loyal",
+  "lucky",
+  "lunar",
+  "mellow",
+  "merry",
+  "mighty",
+  "mint",
+  "misty",
+  "nimble",
+  "noble",
+  "opal",
+  "patient",
+  "peppy",
+  "placid",
+  "plucky",
+  "polar",
+  "prim",
+  "proud",
+  "quick",
+  "quiet",
+  "quirky",
+  "radiant",
+  "rapid",
+  "ready",
+  "regal",
+  "rosy",
+  "royal",
+  "rugged",
+  "sage",
+  "sandy",
+  "scarlet",
+  "serene",
+  "sharp",
+  "shiny",
+  "silent",
+  "silver",
+  "sleek",
+  "smooth",
+  "snappy",
+  "snowy",
+  "solar",
+  "spry",
+  "stellar",
+  "sturdy",
+  "sunny",
+  "swift",
+  "tender",
+  "tidal",
+  "tidy",
+  "tranquil",
+  "trusty",
+  "upbeat",
+  "valiant",
+  "vivid",
+  "warm",
+  "whimsical",
+  "wise",
+  "witty",
+  "zesty",
+  "zippy"
+];
+const ANIMALS = [
+  "ant",
+  "badger",
+  "bat",
+  "bear",
+  "beaver",
+  "bee",
+  "bison",
+  "boar",
+  "bobcat",
+  "buffalo",
+  "camel",
+  "caribou",
+  "cat",
+  "cheetah",
+  "cobra",
+  "condor",
+  "cougar",
+  "coyote",
+  "crab",
+  "crane",
+  "cricket",
+  "crow",
+  "deer",
+  "dingo",
+  "dolphin",
+  "donkey",
+  "dove",
+  "dragon",
+  "duck",
+  "eagle",
+  "eel",
+  "egret",
+  "elk",
+  "falcon",
+  "ferret",
+  "finch",
+  "fox",
+  "frog",
+  "gecko",
+  "gibbon",
+  "goat",
+  "goose",
+  "gopher",
+  "hare",
+  "hawk",
+  "hedgehog",
+  "heron",
+  "hippo",
+  "horse",
+  "ibex",
+  "ibis",
+  "iguana",
+  "jackal",
+  "jaguar",
+  "jay",
+  "kestrel",
+  "koala",
+  "krill",
+  "lark",
+  "lemur",
+  "leopard",
+  "lion",
+  "llama",
+  "lynx",
+  "macaw",
+  "magpie",
+  "mantis",
+  "marmot",
+  "marten",
+  "meerkat",
+  "mink",
+  "mole",
+  "moose",
+  "moth",
+  "mouse",
+  "newt",
+  "ocelot",
+  "octopus",
+  "orca",
+  "osprey",
+  "otter",
+  "owl",
+  "ox",
+  "panda",
+  "panther",
+  "parrot",
+  "pelican",
+  "penguin",
+  "pheasant",
+  "pigeon",
+  "puffin",
+  "puma",
+  "quail",
+  "rabbit",
+  "raccoon",
+  "ram",
+  "raven",
+  "robin",
+  "salmon",
+  "seal",
+  "shark",
+  "sheep",
+  "shrew",
+  "skunk",
+  "sloth",
+  "snail",
+  "sparrow",
+  "spider",
+  "squid",
+  "stag",
+  "stoat",
+  "stork",
+  "swan",
+  "tapir",
+  "tiger",
+  "toad",
+  "trout",
+  "turtle",
+  "viper",
+  "vole",
+  "walrus",
+  "weasel",
+  "whale",
+  "wolf",
+  "wombat",
+  "wren",
+  "yak",
+  "zebra"
+];
+function pick(arr) {
+  const n = arr.length;
+  const max = Math.floor(256 / n) * n;
+  let b;
+  do {
+    b = randomBytes(1)[0];
+  } while (b >= max);
+  return arr[b % n];
+}
+function generateFriendlyName(taken = []) {
+  const used = taken instanceof Set ? taken : new Set(taken);
+  for (let i = 0; i < 1e3; i++) {
+    const name = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+    if (!used.has(name)) return name;
+  }
+  const base = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+  let n = 2;
+  while (used.has(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+function sanitizeSegment(s) {
+  return String(s || "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function friendlyNameFromId(id) {
+  const m = /^(.+)-[a-zA-Z0-9]{6,10}$/.exec(String(id || ""));
+  return m ? m[1] : void 0;
+}
+function composeSessionId(friendlyName, takenIds = [], len = 6) {
+  const taken = takenIds instanceof Set ? takenIds : new Set(takenIds);
+  const A = LOWER_ALPHABET.length;
+  const nthSuffix = (i, width2) => {
+    let s = "";
+    for (let k = 0; k < width2; k++) {
+      s = LOWER_ALPHABET[i % A] + s;
+      i = Math.floor(i / A);
+    }
+    return s;
+  };
+  let width = Math.max(1, len);
+  for (; ; ) {
+    const space = Math.pow(A, width);
+    for (let i = 0; i < 64; i++) {
+      const candidate = `${friendlyName}-${shortId(width, LOWER_ALPHABET)}`;
+      if (!taken.has(candidate)) return candidate;
+    }
+    if (space <= 1e6) {
+      for (let i = 0; i < space; i++) {
+        const candidate = `${friendlyName}-${nthSuffix(i, width)}`;
+        if (!taken.has(candidate)) return candidate;
+      }
+    }
+    width++;
+  }
+}
+function formatHandle(projectName, friendlyName) {
+  if (!friendlyName) return void 0;
+  const proj = sanitizeSegment(projectName || "");
+  return proj ? `${proj}:${friendlyName}` : friendlyName;
+}
+function parseHandle(input) {
+  const str = String(input || "").trim().replace(/^@/, "");
+  if (!str) return null;
+  const i = str.indexOf(":");
+  if (i === -1) return { name: str.toLowerCase() };
+  return { project: sanitizeSegment(str.slice(0, i)), name: str.slice(i + 1).toLowerCase() };
+}
+function handleMatchesMetadata(parsed, metadata) {
+  const fn = String(metadata?.friendlyName || "").toLowerCase();
+  if (!fn || fn !== parsed.name) return false;
+  if (parsed.project) {
+    return sanitizeSegment(metadata?.projectName || "") === parsed.project;
+  }
+  return true;
+}
+
+export { friendlyNameFromId as a, composeSessionId as c, formatHandle as f, generateFriendlyName as g, handleMatchesMetadata as h, parseHandle as p, shortId as s };

package/dist/{headlessCli-C8HzQvis.mjs → headlessCli-BpTXz6FD.mjs}

@@ -261,6 +261,10 @@ async function createPorcupineWakeWord(opts) {
   };
 }
 
+const DEFAULT_REALTIME_MODEL = "gpt-realtime-mini";
+function resolveRealtimeModel(explicit, env) {
+  return explicit || env.WISE_VOICE_MODEL || DEFAULT_REALTIME_MODEL;
+}
 async function runWiseVoiceCli(opts = {}) {
   const resolved = resolveModel({ provider: "openai" }, process.env);
   const mis = describeMisconfiguration(resolved);
@@ -286,30 +290,34 @@ async function runWiseVoiceCli(opts = {}) {
     }
   }
   const audio = createSoxAudioAdapter();
-  console.log(`\u25CF WISE headless voice \u2014 ${tools.length} tools | model ${opts.model || resolved.model || "gpt-realtime-mini"} | ${wakeWord ? `wake: "${opts.wakeKeywordPath}"` : "always-listening (Ctrl-C to stop)"}`);
+  const realtimeModel = resolveRealtimeModel(opts.model, process.env);
+  console.log(`\u25CF WISE headless voice \u2014 ${tools.length} tools | model ${realtimeModel} | ${wakeWord ? `wake: "${opts.wakeKeywordPath}"` : "always-listening (Ctrl-C to stop)"}`);
   const loop = runHeadlessVoice({
     apiKey: resolved.apiKey,
     baseUrl: resolved.baseUrl,
-    config: { instructions, tools, voice: opts.voice, model: opts.model || resolved.model },
+    config: { instructions, tools, voice: opts.voice, model: realtimeModel },
+    // #1710
     audio,
     wakeWord,
     onTool: (t) => console.log(`  \u21B3 ${t.name}: ${t.output.slice(0, 120).replace(/\n/g, " ")}`),
     onError: (e) => console.error(`  ! ${e.message}`)
   });
-  const shutdown = () => {
-    console.log("\nstopping\u2026");
-    try {
-      loop.stop();
-    } catch {
-    }
-    try {
-      audio.close();
-    } catch {
-    }
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  await new Promise((resolve) => {
+    const shutdown = () => {
+      console.log("\nstopping\u2026");
+      try {
+        loop.stop();
+      } catch {
+      }
+      try {
+        audio.close();
+      } catch {
+      }
+      resolve();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
 }
 
 export { runWiseVoiceCli };

package/dist/{hookSettings-FFc1pi8j.mjs → hookSettings-CvvUhwCK.mjs}

@@ -22,10 +22,10 @@ import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as r
 import os, { homedir as homedir$1 } from 'node:os';
 import { join as join$1, extname, resolve, sep, basename, dirname } from 'node:path';
 import { e as envFlagEnabled, a as envFlagDisabled } from './envFlag-COOuJ3AH.mjs';
-import { normalizeProxyUrl, resolveHyphaProxyUrl, applyClaudeProxyEnv } from './claudeAuth-C0wc1GTM.mjs';
+import { normalizeProxyUrl, resolveHyphaProxyUrl, applyClaudeProxyEnv } from './claudeAuth-DMDvPNhO.mjs';
 import { CODEX_PROVIDER_KEY_ENV } from './codexProvider-BtxYc5Rj.mjs';
 import { spawn as spawn$1 } from 'node:child_process';
-import { b as applyInboxClear } from './friendlyName-1UZcyDhu.mjs';
+import { applyInboxClear } from './inboxGuard-CDqmIypF.mjs';
 import { w as withFileLock, s as sleepSync } from './fileLock-BMPwCrB6.mjs';
 import { EventEmitter } from 'node:events';
 import { r as renderTemplate } from './cron-hHGdb5kU.mjs';
@@ -603,8 +603,11 @@ class ProcessSupervisor {
       if (!file.endsWith(".json")) continue;
       try {
         const raw = await readFile(path__default.join(this.persistDir, file), "utf-8");
-        const spec = JSON.parse(raw);
-        const entry = this.makeEntry(spec);
+        const parsed = JSON.parse(raw);
+        const restored = parsed?.__state;
+        delete parsed.__state;
+        const spec = parsed;
+        const entry = this.makeEntry(spec, restored);
         this.entries.set(spec.id, entry);
         if (spec.keepAlive && !spec.desiredStopped) {
           await this.startEntry(
@@ -627,12 +630,49 @@ class ProcessSupervisor {
       console.log(`[SUPERVISOR] Restored ${loaded} supervised process(es)`);
     }
   }
-  async persistSpec(spec) {
+  /**
+   * #1643: the crash-loop LEDGER travels with the spec.
+   *
+   * `ProcessState` is annotated "not persisted", and `makeEntry` zeroes restartCount /
+   * consecutiveFailures / crashLoopBackOff on every restore — so a permanently-broken keepAlive
+   * spec (dead upstream, taken port, vanished workdir) got a FRESH 10-restart budget on every
+   * daemon start, forever. It burns CRASH_LOOP_FAILURE_THRESHOLD restarts and ~15 min of
+   * exponential spawn churn, parks crash-loop-backoff, and starts over on the next boot —
+   * undermining the cap that exists because of the "11,508 restarts in 4 days" incident, and
+   * worst right after a reboot when several dead specs churn at once. `svamp process list` also
+   * showed RESTARTS 0 after every restart, which hid it. The #1633 docblock states this for the
+   * missing-workdir case; it is general.
+   *
+   * Written under a `__state` key so the file stays a superset of ProcessSpec: an older daemon
+   * ignores it, and `loadAll` strips it before the object becomes `entry.spec`.
+   */
+  async persistSpec(spec, state, failureWindowStart) {
     const filePath = path__default.join(this.persistDir, `${spec.id}.json`);
+    if (!state) {
+      const live = this.entries.get(spec.id);
+      if (live) {
+        state = live.state;
+        failureWindowStart = live.failureWindowStart;
+      }
+    }
     const tmpPath = `${filePath}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
-    await writeFile(tmpPath, JSON.stringify(spec, null, 2), "utf-8");
+    const payload = { ...spec };
+    if (state) {
+      payload.__state = {
+        restartCount: state.restartCount,
+        userRestartCount: state.userRestartCount,
+        consecutiveFailures: state.consecutiveFailures,
+        crashLoopBackOff: state.crashLoopBackOff,
+        failureWindowStart
+      };
+    }
+    await writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
     await rename(tmpPath, filePath);
   }
+  /** #1643: rewrite this spec's file including its live crash-loop ledger. Best-effort. */
+  persistLedger(entry) {
+    void this.persistSpec(entry.spec, entry.state, entry.failureWindowStart).catch((err) => console.error(`[SUPERVISOR] Failed to persist crash-loop ledger for ${entry.spec.name}: ${err?.message || err}`));
+  }
   async deleteSpec(id) {
     try {
       await unlink(path__default.join(this.persistDir, `${id}.json`));
@@ -640,17 +680,22 @@ class ProcessSupervisor {
     }
   }
   // ── Internal helpers ──────────────────────────────────────────────────────
-  makeEntry(spec) {
+  makeEntry(spec, restored) {
     return {
       spec,
       state: {
         id: spec.id,
         status: "pending",
-        restartCount: 0,
-        userRestartCount: 0,
+        // #1643: a restored ledger carries the crash-loop budget ACROSS the restart. Without
+        // it, `maxRestarts` and CRASH_LOOP_FAILURE_THRESHOLD were per-boot rather than
+        // lifetime caps, which is not what either of them claims to be.
+        restartCount: restored?.restartCount ?? 0,
+        userRestartCount: restored?.userRestartCount ?? 0,
         consecutiveProbeFailures: 0,
-        consecutiveFailures: 0
+        consecutiveFailures: restored?.consecutiveFailures ?? 0,
+        crashLoopBackOff: restored?.crashLoopBackOff
       },
+      failureWindowStart: restored?.failureWindowStart,
       logBuffer: [],
       stopping: false
     };
@@ -781,6 +826,7 @@ class ProcessSupervisor {
       );
       return;
     }
+    this.persistLedger(entry);
     if (spec.maxRestarts > 0 && state.restartCount >= spec.maxRestarts) {
       console.warn(`[SUPERVISOR] Process '${spec.name}' reached max restarts (${spec.maxRestarts}), not restarting`);
       state.status = "failed";
@@ -804,6 +850,7 @@ class ProcessSupervisor {
       if (entry.child) return;
       state.restartCount++;
       state.status = "starting";
+      this.persistLedger(entry);
       this.spawnProcess(entry);
     }, delayMs);
   }
@@ -6066,6 +6113,15 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const callerEmail = context?.user?.email;
         const machineOwner = currentMetadata.sharing?.owner;
         const isSharedUser = callerEmail && machineOwner && callerEmail.toLowerCase() !== machineOwner.toLowerCase();
+        if (options.sharing?.allowedUsers?.length) {
+          options = {
+            ...options,
+            sharing: {
+              ...options.sharing,
+              allowedUsers: options.sharing.allowedUsers.map((u) => normalizeAllowedUser(u, "spawn"))
+            }
+          };
+        }
         if (isSharedUser) {
           const sharing = {
             enabled: true,
@@ -7570,7 +7626,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
       return { ok: false, call_id: callId, status: "busy", error: "channel is busy (too many concurrent requests) \u2014 retry shortly" };
     }
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-B-yczgz_.mjs');
+    const { queryCore } = await import('./commands-CcdoQIkb.mjs').then(function (n) { return n.d; });
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     let thrownSessionId;
@@ -7957,6 +8013,14 @@ function loadInbox(projectDir, sessionId) {
     return [];
   }
 }
+const reportedInboxWriteErrnos = /* @__PURE__ */ new Set();
+function reportInboxWriteFailure(projectDir, sessionId, err) {
+  const code = String(err?.code || err?.name || "UNKNOWN");
+  if (reportedInboxWriteErrnos.has(code)) return;
+  reportedInboxWriteErrnos.add(code);
+  const hint = code === "ENOSPC" ? ' \u2014 THE DISK IS FULL. Pending inter-agent messages will be LOST on the next daemon restart and `inbox reply` will answer "not found"; session transcripts are likely failing too.' : code === "EROFS" ? " \u2014 the filesystem is read-only." : code === "EACCES" || code === "EPERM" ? " \u2014 permission denied on the session .svamp directory." : code === "ENOTDIR" ? " \u2014 a path component of .svamp/<sessionId>/ is a FILE, not a directory." : "";
+  console.error(`[inbox] persist failed for session ${sessionId} in ${projectDir} (${code})${hint} Further ${code} failures will not be repeated. (#1714)`);
+}
 function saveInbox(projectDir, sessionId, inbox) {
   try {
     const p = inboxFilePath(projectDir, sessionId);
@@ -7964,7 +8028,8 @@ function saveInbox(projectDir, sessionId, inbox) {
     const tmp = `${p}.tmp-${process.pid}-${randomBytes$1(4).toString("hex")}`;
     writeFileSync$1(tmp, JSON.stringify(inbox));
     renameSync(tmp, p);
-  } catch {
+  } catch (err) {
+    reportInboxWriteFailure(projectDir, sessionId, err);
   }
 }
 function isPending(m) {
@@ -8255,25 +8320,34 @@ async function _mintPairingCodeLocked(opts, resolver, ttlMs) {
     stage: true,
     _rkwargs: true
   });
-  const putUrl = await am.put_file({ artifact_id: artifactId, file_path: "pair.json", download_weight: 0, _rkwargs: true });
-  if (!putUrl || typeof putUrl !== "string") throw new Error(`put_file returned invalid URL: ${putUrl}`);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 3e4);
-  try {
-    const resp = await fetch(putUrl, {
-      method: "PUT",
-      body: pairJson,
-      headers: { "Content-Type": "application/json" },
-      signal: controller.signal
-    });
-    if (!resp.ok) throw new Error(`pair.json upload failed: ${resp.status} ${resp.statusText}`);
-  } finally {
-    clearTimeout(timer);
-  }
-  await am.commit({ artifact_id: artifactId, _rkwargs: true });
   const all = loadPairings(opts.svampHome);
   all.push({ session, code, artifactId, expiresAt, createdAt: now });
   savePairings(all, opts.svampHome);
+  try {
+    const putUrl = await am.put_file({ artifact_id: artifactId, file_path: "pair.json", download_weight: 0, _rkwargs: true });
+    if (!putUrl || typeof putUrl !== "string") throw new Error(`put_file returned invalid URL: ${putUrl}`);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const resp = await fetch(putUrl, {
+        method: "PUT",
+        body: pairJson,
+        headers: { "Content-Type": "application/json" },
+        signal: controller.signal
+      });
+      if (!resp.ok) throw new Error(`pair.json upload failed: ${resp.status} ${resp.statusText}`);
+    } finally {
+      clearTimeout(timer);
+    }
+    await am.commit({ artifact_id: artifactId, _rkwargs: true });
+  } catch (err) {
+    try {
+      await deletePairingArtifact(am, artifactId, log);
+      savePairings(loadPairings(opts.svampHome).filter((p) => p.artifactId !== artifactId), opts.svampHome);
+    } catch {
+    }
+    throw err;
+  }
   log?.(`[OUTPOST PAIRING] minted ${code} for ${session} (expires in ${Math.round(ttlMs / 6e4)}m)`);
   return { code, resolver, expiresAt };
 }
@@ -8499,6 +8573,24 @@ function channelPublicView(c) {
 function isStructuredMessage(msg) {
   return !!(msg.from || msg.fromSession || msg.subject || msg.replyTo || msg.threadId || msg.channel);
 }
+function reportInboxEviction(result, sessionId) {
+  for (const m of result.droppedUndelivered) {
+    console.warn(
+      `[HYPHA SESSION ${sessionId}] inbox at cap: DROPPED AN UNDELIVERED message ${m.messageId || "<no id>"} from ${m.from || "<unknown>"} (urgency=${m.urgency || "normal"}). Every resident message was undelivered, so there was no delivered one to evict instead. The sender was told it was sent; it is now gone (#0328).`
+    );
+  }
+}
+function evictInboxOverflow(inbox, max) {
+  const dropped = [];
+  const droppedUndelivered = [];
+  while (inbox.length > max) {
+    const idx = inbox.findIndex((m) => m.handled);
+    const victim = inbox.splice(idx < 0 ? 0 : idx, 1)[0];
+    dropped.push(victim);
+    if (!victim.handled) droppedUndelivered.push(victim);
+  }
+  return { dropped, droppedUndelivered };
+}
 function escapeXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -8958,7 +9050,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       subject: `Remote outpost connected: ${who}`
     };
     inbox.push(msg);
-    while (inbox.length > INBOX_MAX) inbox.shift();
+    reportInboxEviction(evictInboxOverflow(inbox, INBOX_MAX), sessionId);
     syncInboxToMetadata();
     callbacks.onInboxMessage?.(msg);
     notifyListeners({ type: "inbox-update", sessionId, message: msg });
@@ -10075,7 +10167,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       const trusted = !context?.user || isSameOwnerWorkspace(context) || !!metadata.sharing && getEffectiveRole(context, metadata.sharing) === "admin";
       const msg = sanitizeInboundInboxMessage(message, { trusted, callerEmail: context?.user?.email });
       inbox.push(msg);
-      while (inbox.length > INBOX_MAX) inbox.shift();
+      reportInboxEviction(evictInboxOverflow(inbox, INBOX_MAX), sessionId);
       syncInboxToMetadata();
       callbacks.onInboxMessage?.(msg);
       notifyListeners({ type: "inbox-update", sessionId, message: msg });