@securecoms/agent-bridge 0.28.0 → 0.28.2

package/README.md

@@ -798,6 +798,39 @@ If you embed the bridge as a library (`new BridgeAgent(cfg, deps)`), semantic re
 
 ---
 
+## Release notes: 0.28.2
+
+<!-- [COPY, NEW] this section. Approved by Eric 2026-10-09 ("approve 0.28.2 copy"). -->
+
+0.28.2 keeps semantic memory recall working after quiet periods. Install it in
+place of 0.28.1 and restart the bridge. `@securecoms/agent-runtime` 0.11.0 is
+unchanged.
+
+- **After a quiet period.** When the agent has been idle for 30 minutes or
+  more, the first private message now waits for the memory search inside the
+  same time limit (600 ms typed, 250 ms in a voice call) instead of skipping it.
+  If the limit runs out, that message has no recall, and the next one does.
+- **Idle is not an error.** The memory helper process still stops after 30 idle
+  minutes to free memory. The bridge no longer logs or reports that as
+  unavailable.
+
+## Release notes: 0.28.1
+
+<!-- [COPY, NEW] this section. Gate: Eric sign-off before npm publish (release PR). -->
+
+0.28.1 makes semantic memory recall more reliable. Install it in place of
+0.28.0 and restart the bridge. `@securecoms/agent-runtime` 0.11.0 is unchanged.
+
+- **After a restart.** When the model files are already on the machine, the
+  bridge loads the owner's private-chat memory at startup, so the first
+  messages after a restart get recall. Without the files, the model still
+  downloads on the owner's first private message, as before.
+- **Time limit.** The bridge now waits up to 600 ms for a typed message's
+  memory search and up to 250 ms during a voice call (it was 150 ms for both).
+- **Idle cache.** A memory cache in use is no longer dropped after 30 minutes.
+- **`/healthz`.** New `recall_cache_bytes`: the bytes of this bridge's memory
+  caches, a number only.
+
 ## Release notes: 0.28.0
 
 0.28.0 adds semantic memory in the owner's private chat. Install it together

package/dist/bin.js

@@ -30085,6 +30085,7 @@ init_manifest();
 // src/memory/embedder/protocol.ts
 import { StringDecoder } from "node:string_decoder";
 var EMBEDDER_PROTOCOL = 1;
+var EMBEDDER_IDLE_MS = 30 * 6e4;
 var MAX_LINE_BYTES = 69632;
 function decodeVec64(s) {
   const b = Buffer.from(s, "base64");
@@ -30476,6 +30477,7 @@ var INERT_EMBEDDER = Object.freeze({
   ensureStarted: () => {
   },
   filesPresent: () => false,
+  ready: () => Promise.resolve(false),
   embed: () => Promise.reject(new Error("inert embedder"))
 });
 var SERVER_CODES = /* @__PURE__ */ new Set(["busy", "too_long", "worker_reset", "failed"]);
@@ -30505,6 +30507,10 @@ var EmbedderClient = class {
   verifyAttempt = 0;
   fails = 0;
   closed = false;
+  /** When this client last sent a job (or connected, if later): the idle-stop test (cold-path ruling 2026-10-09). */
+  lastActivity = -Infinity;
+  /** ready(ms) waiters: settled on the next transition out of "preparing". */
+  readyWaiters = /* @__PURE__ */ new Set();
   m;
   now;
   log;
@@ -30512,6 +30518,24 @@ var EmbedderClient = class {
   state() {
     return this.st;
   }
+  /** Cold-path ruling (2026-10-09): see Embedder.ready. Pure like state(): never starts, connects or spawns anything. */
+  ready(ms) {
+    if (this.st.state === "ready") return Promise.resolve(true);
+    if (this.st.state !== "preparing" || !(ms > 0)) return Promise.resolve(false);
+    return new Promise((resolve3) => {
+      let t;
+      const w = (ok) => {
+        clearTimeout(t);
+        this.readyWaiters.delete(w);
+        resolve3(ok);
+      };
+      this.readyWaiters.add(w);
+      t = setTimeout(() => w(false), ms);
+    });
+  }
+  settleReady(ok) {
+    for (const w of [...this.readyWaiters]) w(ok);
+  }
   tcp() {
     return (this.o.platform ?? process.platform) === "win32";
   }
@@ -30580,6 +30604,24 @@ var EmbedderClient = class {
     for (const p of this.pending.values()) p.rej(new Error(reason));
     this.pending.clear();
     if (reason !== "verify_failed" && reason !== "embedder_crashed") this.notBefore = Math.max(this.notBefore, this.now() + reconnectDelayMs(++this.fails));
+    this.settleReady(false);
+  }
+  /**
+   * Rule 6, cold-path ruling (2026-10-09): the served socket closed. With no job pending and this client's last job (or
+   * its connect, if later) at least the shared idle constant ago, it is the shared embedder's idle stop, which is not a
+   * failure: back to `off`, no `fails++`, no `notBefore`, no unavailable report, so the next turn's ensureStarted starts
+   * it at once. Anything else (a job pending, or recent use) stays a failure with its backoff.
+   */
+  onServedClose() {
+    if (this.closed) return;
+    if (this.pending.size > 0 || this.now() - this.lastActivity < EMBEDDER_IDLE_MS) return this.fail("embedder_unavailable");
+    this.log("info", "memory.embedder_idle_closed");
+    this.st = { state: "off" };
+    const s = this.sock;
+    this.sock = null;
+    this.chan = null;
+    s?.destroy();
+    this.settleReady(false);
   }
   ensureStarted() {
     if (this.closed || this.st.state === "preparing" || this.st.state === "ready") return;
@@ -30791,9 +30833,11 @@ var EmbedderClient = class {
           this.st = { state: "ready" };
           this.fails = 0;
           this.starts = [];
+          this.lastActivity = this.now();
           s.on("close", () => {
-            if (this.sock === s) this.fail("embedder_unavailable");
+            if (this.sock === s) this.onServedClose();
           });
+          this.settleReady(true);
           done(true);
         } catch {
           refuse("embedder_unavailable");
@@ -30827,6 +30871,7 @@ var EmbedderClient = class {
     const id = ++this.seq;
     const s = this.sock;
     const chan = this.chan;
+    this.lastActivity = this.now();
     return new Promise((res, rej) => {
       const signal = opts.signal;
       const onAbort = () => {
@@ -30855,6 +30900,7 @@ var EmbedderClient = class {
     for (const p of this.pending.values()) p.rej(new Error("closed"));
     this.pending.clear();
     this.st = { state: "off" };
+    this.settleReady(false);
   }
 };
 
@@ -30879,6 +30925,8 @@ function rankRecall(query, cache, o) {
 
 // src/memory/recall/recall-book.ts
 var DIMS = 384;
+var RECALL_QUERY_TIMEOUT_TEXT_MS = 600;
+var RECALL_QUERY_TIMEOUT_VOICE_MS = 250;
 var RecallBook = class _RecallBook {
   constructor(d) {
     this.d = d;
@@ -30932,10 +30980,12 @@ var RecallBook = class _RecallBook {
   static IDLE_MS = 30 * 6e4;
   static TOP_K = 5;
   static TEXT_MAX_CHARS = 2e3;
-  static QUERY_TIMEOUT_MS = 150;
+  /** About 1.5 ms of real opens at the measured ~40 µs per row: the longest a warm holds the event loop. */
+  static WARM_YIELD_ROWS = 32;
   caches = /* @__PURE__ */ new Map();
   entries = /* @__PURE__ */ new Map();
-  warming = /* @__PURE__ */ new Set();
+  /** The warm in flight per conversation: a cold turn awaits the same warm instead of starting a second one. */
+  warming = /* @__PURE__ */ new Map();
   same(a, b) {
     return a.clearGeneration === b.clearGeneration && a.modeEpoch === b.modeEpoch && a.purgeEpoch === b.purgeEpoch && a.contentEpoch === b.contentEpoch;
   }
@@ -30945,6 +30995,15 @@ var RecallBook = class _RecallBook {
   cacheWarm(conversationId) {
     return this.caches.has(conversationId);
   }
+  /**
+   * Task 27 Step 1: the bytes the warm vector caches hold (a number, content-free; /healthz `recall_cache_bytes`).
+   * The backing buffer, not the view: a warm that skipped unreadable rows installs a shorter view of a full buffer.
+   */
+  cacheBytes() {
+    let n = 0;
+    for (const c of this.caches.values()) n += c.vecs.buffer.byteLength;
+    return n;
+  }
   /**
    * §7.3 (H2): snapshot first, open outside the mutex, install under it. Never on a turn's path. Never rejects:
    * a read failure leaves the cache cold (fail closed: no recall).
@@ -30960,15 +31019,23 @@ var RecallBook = class _RecallBook {
    *     re-read rows (ids gone are dropped, the few new ids are opened here, under the mutex) and installed with the
    *     re-read capture.
    */
-  async warm(conversationId) {
-    if (this.warming.has(conversationId)) return;
-    this.warming.add(conversationId);
+  warm(conversationId) {
+    const inFlight = this.warming.get(conversationId);
+    if (inFlight) return inFlight;
+    const w = this.warmOnce(conversationId).finally(() => {
+      if (this.warming.get(conversationId) === w) this.warming.delete(conversationId);
+    });
+    this.warming.set(conversationId, w);
+    return w;
+  }
+  async warmOnce(conversationId) {
     try {
       const snap = this.d.store.readRecallRows(conversationId);
       const rows = snap.rows.filter((r) => r.modelId === this.d.modelId);
       const opened = /* @__PURE__ */ new Map();
       const failed = /* @__PURE__ */ new Set();
-      for (const r of rows) {
+      for (const [i, r] of rows.entries()) {
+        if (i > 0 && i % _RecallBook.WARM_YIELD_ROWS === 0) await new Promise((r2) => setImmediate(r2));
         const v = await this.d.store.openRecallVec(conversationId, r);
         if (!v || v.length !== DIMS) {
           failed.add(r.recallId);
@@ -31010,46 +31077,61 @@ var RecallBook = class _RecallBook {
       if (unreadable > 0) (this.d.log ?? writeServiceLog)("warn", "memory.recall_open_failed", { count: unreadable });
     } catch (e) {
       (this.d.log ?? writeServiceLog)("warn", "memory.recall_warm_failed", {}, e);
-    } finally {
-      this.warming.delete(conversationId);
     }
   }
   /**
    * §7.1: compute at ingest. Snapshot the capture FIRST (H2); `receipt`
    * replaces its purge and mode epochs with the ones captured when the turn
    * was received (Task 16 fix H-2), so a purge or a mode change after receipt
-   * refuses too. 150 ms bound on the query embed; a cold cache starts a warm
-   * and gives nothing.
+   * refuses too.
+   *
+   * Cold-path ruling (architect, 2026-10-09; §7.1 and §7.3 errata): ONE deadline, start + `timeoutMs` (the caller
+   * passes its turn kind's bound: 600 ms text, 250 ms voice), covers the ready wait, the warm and the query embed
+   * together; no phase has a budget of its own. A cold embedder is started (ensureStarted) and waited for; a cold or
+   * stale cache is warmed and waited for. Past the deadline there is no recall and nothing attaches late: a warm that
+   * outlives it keeps running and may install (warm enforces H2 itself), but this turn gets no entry.
    */
   async prepare(p) {
     const fresh = this.d.store.recallCapture(p.conversationId);
     const capture = p.receipt ? { ...fresh, purgeEpoch: p.receipt.purgeEpoch, modeEpoch: p.receipt.modeEpoch } : fresh;
     this.entries.delete(p.messageId);
-    const now = this.nowMs();
-    this.dropIdleCaches(now);
-    if (this.d.embedder.state().state !== "ready") {
-      this.d.embedder.ensureStarted();
-      return;
-    }
-    const cache = this.caches.get(p.conversationId);
-    if (!cache || !this.same(cache.capture, capture)) {
-      void this.warm(p.conversationId);
-      return;
-    }
+    this.dropIdleCaches(this.nowMs());
+    const deadlineAt = Date.now() + p.timeoutMs;
     const ac = new AbortController();
+    let late = false;
     let timer;
-    const q = await Promise.race([
-      this.d.embedder.embed(p.query, 0, { signal: ac.signal }).catch(() => null),
-      new Promise((r) => {
-        timer = setTimeout(() => {
-          ac.abort();
-          r(null);
-        }, p.timeoutMs ?? _RecallBook.QUERY_TIMEOUT_MS);
-      })
-    ]);
-    clearTimeout(timer);
-    if (!q || q.length !== DIMS) return;
-    cache.lastUse = this.nowMs();
+    const expired = new Promise((r) => {
+      timer = setTimeout(() => {
+        late = true;
+        ac.abort();
+        r("expired");
+      }, p.timeoutMs);
+    });
+    try {
+      if (this.d.embedder.state().state !== "ready") {
+        this.d.embedder.ensureStarted();
+        if (await Promise.race([this.d.embedder.ready(Math.max(0, deadlineAt - Date.now())).catch(() => false), expired]) !== true) return;
+      }
+      let cache = this.caches.get(p.conversationId);
+      if (!cache || !this.same(cache.capture, capture)) {
+        const cur = this.d.store.recallCapture(p.conversationId);
+        if (cur.clearGeneration !== capture.clearGeneration || cur.modeEpoch !== capture.modeEpoch || cur.purgeEpoch !== capture.purgeEpoch) return;
+        if (await Promise.race([this.warm(p.conversationId).then(() => "warmed"), expired]) !== "warmed") return;
+        cache = this.caches.get(p.conversationId);
+        if (!cache || !this.same(cache.capture, capture)) return;
+      }
+      cache.lastUse = this.nowMs();
+      const q = await Promise.race([
+        this.d.embedder.embed(p.query, 0, { signal: ac.signal }).catch(() => null),
+        expired.then(() => null)
+      ]);
+      if (!q || q.length !== DIMS) return;
+      await Promise.race([this.attach(p, capture, cache, q, () => late), expired]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async attach(p, capture, cache, q, late) {
     const ranked = rankRecall(
       q,
       { vecs: cache.vecs, dims: DIMS, messageIds: cache.messageIds, recallIds: cache.recallIds },
@@ -31071,7 +31153,7 @@ var RecallBook = class _RecallBook {
       items.push({ id: r.recallId, text, sent_at: row.sentAt });
     }
     if (unreadable > 0) (this.d.log ?? writeServiceLog)("warn", "memory.recall_open_failed", { count: unreadable });
-    if (items.length === 0) return;
+    if (items.length === 0 || late()) return;
     if (this.entries.size >= _RecallBook.MAP_MAX) this.entries.delete(this.entries.keys().next().value);
     this.entries.set(p.messageId, { conversationId: p.conversationId, capture, items });
   }
@@ -33147,6 +33229,19 @@ var BridgeAgent = class _BridgeAgent {
   recallStageEpochs = /* @__PURE__ */ new Map();
   /** 7b Task 16: in-flight fire-and-forget index taps; close() waits for them (bounded). */
   recallTapWork = /* @__PURE__ */ new Set();
+  /**
+   * §13.5 live check (2026-10-09, cold start): set when an apply turns recall on (the boot apply included), cleared
+   * once the maintenance tick has started the DM prewarm, or when recall is off at a tick.
+   */
+  recallPrewarmPending = false;
+  /** The DM prewarm in flight (one at a time); close() waits for it (bounded). */
+  recallPrewarmWork = null;
+  /**
+   * Cold-path ruling B (2026-10-09): conversations whose turn passed Q1/Q2, for the maintenance tick to warm once the
+   * embedder is ready (runRecallPrewarm). Bounded; dropped whenever a tick finds recall off.
+   */
+  recallPrewarmTargets = /* @__PURE__ */ new Set();
+  static RECALL_PREWARM_TARGETS_MAX = 256;
   /**
    * Final-review item 2: conversations whose `audience` skip was already logged in this process. A room (or any
    * conversation the owner-DM gate refuses) refuses every turn the same way, so the line is written once per
@@ -35346,7 +35441,9 @@ var BridgeAgent = class _BridgeAgent {
         await this.notes.exclusive(async () => {
           if (this.store.applyRecallMode("semantic", mem.recallDays).purged > 0) this.onRecallRetentionChangedLocked();
         });
+        const turnedOn = !this.recallConfig.on;
         this.recallConfig = { on: true };
+        if (turnedOn) this.armRecallPrewarm();
         if (this.cfg.modelSource === "download" && !this.modelDownloadNoticeLogged) {
           this.modelDownloadNoticeLogged = true;
           writeServiceLog("info", "memory.model_download_enabled");
@@ -35367,6 +35464,59 @@ var BridgeAgent = class _BridgeAgent {
       writeServiceLog("warn", "memory.recall_mode_failed", {}, e);
     }
   }
+  /**
+   * §13.5 live check (2026-10-09, cold start). After a restart in semantic mode turn 1 got no recall (the embedder
+   * was not ready: ensureStarted, return) and turn 2 none either (no cache: a background warm, return). So when an
+   * apply turns recall on (the boot apply included) and the model files are on disk, the embedder is started here,
+   * off the turn path; the
+   * maintenance tick warms the DM caches once it is ready (runRecallPrewarm). Synchronous and never throws:
+   * ensureStarted only schedules the start, so boot never waits for it.
+   */
+  armRecallPrewarm() {
+    try {
+      if (!this.recallProviderOn()) return;
+      if (!this.embedder.filesPresent()) return;
+      this.recallPrewarmPending = true;
+      this.embedder.ensureStarted();
+    } catch (e) {
+      writeServiceLog("warn", "memory.recall_prewarm_failed", {}, e);
+    }
+  }
+  /**
+   * The maintenance tick's half of the cold-start prewarm: once the embedder is ready (no cache RAM is spent on an
+   * embedder that may never come up), warm each DM conversation, one at a time, detached from the tick. DM is the
+   * persisted is_dm === true, the rule the membership sweep uses (audit r1 M6); a vault channel is never one. The
+   * prewarm only opens vectors through RecallBook.warm, which snapshots the capture first and installs nothing
+   * across a clear, a mode change or a purge (H2, M-A3). It indexes nothing and prepares nothing. Recall turned off
+   * before or during it stops it (I1, Q1). Never throws.
+   */
+  runRecallPrewarm() {
+    if (!this.recallPrewarmPending && this.recallPrewarmTargets.size === 0 || this.recallPrewarmWork || this.closingDown) return;
+    if (this.embedder.state().state !== "ready") return;
+    const all = this.recallPrewarmPending;
+    this.recallPrewarmPending = false;
+    const targets = [...this.recallPrewarmTargets];
+    this.recallPrewarmTargets.clear();
+    this.recallPrewarmWork = (async () => {
+      try {
+        const isDm = (c) => !this.vaultChannelIds.has(c) && this.store.getChannelMeta(c)?.isDm === true;
+        const dms = [.../* @__PURE__ */ new Set([...targets, ...all ? this.store.memoryConversationIds() : []])].filter(isDm);
+        for (const c of dms) {
+          if (this.closingDown || !this.recallProviderOn()) return;
+          if (this.recall.cacheWarm(c)) continue;
+          await this.recall.warm(c);
+        }
+      } catch (e) {
+        writeServiceLog("warn", "memory.recall_prewarm_failed", {}, e);
+      }
+    })().finally(() => {
+      this.recallPrewarmWork = null;
+    });
+  }
+  /** @internal test seam: resolves once the DM prewarm in flight, if any, has settled. */
+  async settleRecallPrewarm() {
+    await this.recallPrewarmWork;
+  }
   /** A retention change or a prune removed rows: drop the vector caches. Called only inside notes.exclusive. */
   onRecallRetentionChangedLocked() {
     this.recall.dropAllCachesLocked();
@@ -35376,8 +35526,8 @@ var BridgeAgent = class _BridgeAgent {
     this.recall.dropAllLocked();
   }
   /**
-   * 7b spec §7.1, §7.2: Q1 (config half) and Q2 here, then the 150 ms bound
-   * inside RecallBook.prepare. Called beside prepareNotesForTurn, before the
+   * 7b spec §7.1, §7.2: Q1 (config half) and Q2 here, then the turn kind's
+   * bound inside RecallBook.prepare (600 ms text, 250 ms voice; ruling 2026-10-09). Called beside prepareNotesForTurn, before the
    * turn is staged. The receipt epochs (Task 16 fix H-2) narrow the capture:
    * the in-cycle receipt, else the persisted staging marks; marks that exist
    * but lack an epoch give no recall (fail closed). Never throws.
@@ -35385,11 +35535,13 @@ var BridgeAgent = class _BridgeAgent {
   async prepareRecallForTurn(t) {
     try {
       if (!this.recallProviderOn() || !this.notesReadable(t.authorization)) return;
+      if (this.recallPrewarmTargets.size < _BridgeAgent.RECALL_PREWARM_TARGETS_MAX) this.recallPrewarmTargets.add(t.channelId);
       const marks = this.recallReceipt.get(t.messageId) ?? this.recallStageEpochs.get(t.messageId);
       if (marks !== void 0 && (marks.purgeEpoch === void 0 || marks.modeEpoch === void 0)) return;
       const receipt = marks === void 0 ? void 0 : { purgeEpoch: marks.purgeEpoch, modeEpoch: marks.modeEpoch };
       const exclude = this.store.recentMemoryMessageIds(t.channelId, 50);
-      await this.recall.prepare({ messageId: t.messageId, conversationId: t.channelId, query: t.text, excludeIds: exclude, ...receipt ? { receipt } : {} });
+      const timeoutMs = t.kind === "voice" ? RECALL_QUERY_TIMEOUT_VOICE_MS : RECALL_QUERY_TIMEOUT_TEXT_MS;
+      await this.recall.prepare({ messageId: t.messageId, conversationId: t.channelId, query: t.text, excludeIds: exclude, timeoutMs, ...receipt ? { receipt } : {} });
     } catch (e) {
       writeServiceLog("warn", "memory.recall_prepare_failed", {}, e);
     }
@@ -35551,8 +35703,11 @@ var BridgeAgent = class _BridgeAgent {
     }
     if (!this.recallProviderOn()) {
       this.reembedHot = false;
+      this.recallPrewarmPending = false;
+      this.recallPrewarmTargets.clear();
       return;
     }
+    this.runRecallPrewarm();
     if (!this.reembedHot && n % 60 !== 0) return;
     try {
       this.reembedHot = await this.reembed.tick() > 0;
@@ -37344,7 +37499,10 @@ var BridgeAgent = class _BridgeAgent {
             const turnText = parsed.text;
             const isCallStart = turnText.trim() === VOICE_CALL_START_MARKER;
             const coalescible = this.voiceCoalesceWindowMs > 0 && m.voiceMode === true && speaker !== void 0 && parsed.transcribed === true && voiceGuidance !== void 0 && !isCallStart;
-            if (!coalescible) await this.prepareRecallForTurn({ channelId: m.channelId, messageId: m.messageId, text: parsed.text, authorization: turnAuthorization });
+            if (!coalescible) {
+              const kind2 = m.voiceMode === true || parsed.transcribed === true ? "voice" : "text";
+              await this.prepareRecallForTurn({ channelId: m.channelId, messageId: m.messageId, text: parsed.text, authorization: turnAuthorization, kind: kind2 });
+            }
             let fastPathRoomBlocked = false;
             if (!coalescible && fastPathEligible && meta && meta.is_dm === false) {
               const reserved = this.fastReplyReserved.get(m.channelId) ?? 0;
@@ -37428,7 +37586,7 @@ var BridgeAgent = class _BridgeAgent {
                 const [firstId, ...tailIds] = win.ids;
                 if (tailIds.length) this.voiceCoalescedTails.set(firstId, tailIds);
                 const text = win.parts.join(" ");
-                await this.prepareRecallForTurn({ channelId, messageId: firstId, text, authorization: turnAuthorization });
+                await this.prepareRecallForTurn({ channelId, messageId: firstId, text, authorization: turnAuthorization, kind: "voice" });
                 const merged = { ...held, text };
                 void recordInboundMemory(this.memory, channelId, senderId, text, firstId, "voice", win.purgeEpoch);
                 let roomBlocked = false;
@@ -38174,6 +38332,7 @@ var BridgeAgent = class _BridgeAgent {
       retired_drained: this.provider.retiredDrainedCount(),
       // INV-CUSTODY-DURABLE §5.C.3: custody health.
       expired_drained: this.provider.expiredDrainedCount(),
+      recall_cache_bytes: this.recall.cacheBytes(),
       custody_persist_failing: this.provider.custodyHealth().persistFailing,
       custody_persist_failures: this.provider.custodyHealth().persistFailures,
       custody_read_failing: this.provider.custodyHealth().readFailing,
@@ -38307,6 +38466,16 @@ var BridgeAgent = class _BridgeAgent {
       ]);
       if (timer) clearTimeout(timer);
     }
+    if (this.recallPrewarmWork) {
+      let timer;
+      await Promise.race([
+        this.recallPrewarmWork,
+        new Promise((resolve3) => {
+          timer = setTimeout(resolve3, _BridgeAgent.GRACEFUL_DRAIN_MS);
+        })
+      ]);
+      if (timer) clearTimeout(timer);
+    }
     this.embedder.close?.();
     if (this.replyWork.size) {
       let timer;

package/dist/bridge-agent.d.ts

@@ -1192,6 +1192,19 @@ export declare class BridgeAgent {
     private readonly recallStageEpochs;
     /** 7b Task 16: in-flight fire-and-forget index taps; close() waits for them (bounded). */
     private readonly recallTapWork;
+    /**
+     * §13.5 live check (2026-10-09, cold start): set when an apply turns recall on (the boot apply included), cleared
+     * once the maintenance tick has started the DM prewarm, or when recall is off at a tick.
+     */
+    private recallPrewarmPending;
+    /** The DM prewarm in flight (one at a time); close() waits for it (bounded). */
+    private recallPrewarmWork;
+    /**
+     * Cold-path ruling B (2026-10-09): conversations whose turn passed Q1/Q2, for the maintenance tick to warm once the
+     * embedder is ready (runRecallPrewarm). Bounded; dropped whenever a tick finds recall off.
+     */
+    private readonly recallPrewarmTargets;
+    private static readonly RECALL_PREWARM_TARGETS_MAX;
     /**
      * Final-review item 2: conversations whose `audience` skip was already logged in this process. A room (or any
      * conversation the owner-DM gate refuses) refuses every turn the same way, so the line is written once per
@@ -2001,13 +2014,33 @@ export declare class BridgeAgent {
     private applyPayloadMemory;
     /** Spec §5.3 (H3): mode state lives in the store; level-triggered after every refetch. Never throws. */
     private applyRecallModeFromPayload;
+    /**
+     * §13.5 live check (2026-10-09, cold start). After a restart in semantic mode turn 1 got no recall (the embedder
+     * was not ready: ensureStarted, return) and turn 2 none either (no cache: a background warm, return). So when an
+     * apply turns recall on (the boot apply included) and the model files are on disk, the embedder is started here,
+     * off the turn path; the
+     * maintenance tick warms the DM caches once it is ready (runRecallPrewarm). Synchronous and never throws:
+     * ensureStarted only schedules the start, so boot never waits for it.
+     */
+    private armRecallPrewarm;
+    /**
+     * The maintenance tick's half of the cold-start prewarm: once the embedder is ready (no cache RAM is spent on an
+     * embedder that may never come up), warm each DM conversation, one at a time, detached from the tick. DM is the
+     * persisted is_dm === true, the rule the membership sweep uses (audit r1 M6); a vault channel is never one. The
+     * prewarm only opens vectors through RecallBook.warm, which snapshots the capture first and installs nothing
+     * across a clear, a mode change or a purge (H2, M-A3). It indexes nothing and prepares nothing. Recall turned off
+     * before or during it stops it (I1, Q1). Never throws.
+     */
+    private runRecallPrewarm;
+    /** @internal test seam: resolves once the DM prewarm in flight, if any, has settled. */
+    settleRecallPrewarm(): Promise<void>;
     /** A retention change or a prune removed rows: drop the vector caches. Called only inside notes.exclusive. */
     private onRecallRetentionChangedLocked;
     /** Markdown mode deleted every row: drop the caches and the per-message map. Called only inside notes.exclusive. */
     private onRecallPurgedAllLocked;
     /**
-     * 7b spec §7.1, §7.2: Q1 (config half) and Q2 here, then the 150 ms bound
-     * inside RecallBook.prepare. Called beside prepareNotesForTurn, before the
+     * 7b spec §7.1, §7.2: Q1 (config half) and Q2 here, then the turn kind's
+     * bound inside RecallBook.prepare (600 ms text, 250 ms voice; ruling 2026-10-09). Called beside prepareNotesForTurn, before the
      * turn is staged. The receipt epochs (Task 16 fix H-2) narrow the capture:
      * the in-cycle receipt, else the persisted staging marks; marks that exist
      * but lack an epoch give no recall (fail closed). Never throws.
@@ -2877,6 +2910,9 @@ export declare class BridgeAgent {
         retired_drained: number;
         /** INV-CUSTODY-DURABLE §5.C.6: rows silently drained past expires_at. */
         expired_drained: number;
+        /** 7b Task 27 Step 1: bytes held by this bridge's warm recall vector caches. A number, content-free; the fleet
+         *  RAM script (scripts/ops/semantic-memory-ram-budget.mjs) sums it with the shared embedder's RSS. */
+        recall_cache_bytes: number;
         /** INV-CUSTODY-DURABLE §5.C.3: a decrypted, un-acked row is memory-only
          *  (its durable write failed); a restart now would lose it. */
         custody_persist_failing: boolean;

package/dist/embedder.js

@@ -58,6 +58,7 @@ import { join as join2 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 var EMBEDDER_PROTOCOL = 1;
 var MAX_TEXT_BYTES = 8192;
+var EMBEDDER_IDLE_MS = 30 * 6e4;
 var MAX_LINE_BYTES = 69632;
 function encodeVec64(v) {
   const b = Buffer.alloc(v.length * 4);
@@ -1216,7 +1217,7 @@ async function serve(o, log, p, lock, token, published, server, tcp, publish) {
   let stopped = false;
   const touchIdle = () => {
     clearTimeout(idleTimer);
-    idleTimer = setTimeout(() => void stop("idle"), o.idleMs ?? 30 * 6e4);
+    idleTimer = setTimeout(() => void stop("idle"), o.idleMs ?? EMBEDDER_IDLE_MS);
   };
   const send = (conn, f2) => {
     const s = conns.get(conn);

package/dist/index.js

@@ -29580,6 +29580,7 @@ var TOKENIZER_OPTIONS = Object.freeze({
 // src/memory/embedder/protocol.ts
 import { StringDecoder } from "node:string_decoder";
 var EMBEDDER_PROTOCOL = 1;
+var EMBEDDER_IDLE_MS = 30 * 6e4;
 var MAX_LINE_BYTES = 69632;
 function decodeVec64(s) {
   const b = Buffer.from(s, "base64");
@@ -29970,6 +29971,7 @@ var INERT_EMBEDDER = Object.freeze({
   ensureStarted: () => {
   },
   filesPresent: () => false,
+  ready: () => Promise.resolve(false),
   embed: () => Promise.reject(new Error("inert embedder"))
 });
 var SERVER_CODES = /* @__PURE__ */ new Set(["busy", "too_long", "worker_reset", "failed"]);
@@ -29999,6 +30001,10 @@ var EmbedderClient = class {
   verifyAttempt = 0;
   fails = 0;
   closed = false;
+  /** When this client last sent a job (or connected, if later): the idle-stop test (cold-path ruling 2026-10-09). */
+  lastActivity = -Infinity;
+  /** ready(ms) waiters: settled on the next transition out of "preparing". */
+  readyWaiters = /* @__PURE__ */ new Set();
   m;
   now;
   log;
@@ -30006,6 +30012,24 @@ var EmbedderClient = class {
   state() {
     return this.st;
   }
+  /** Cold-path ruling (2026-10-09): see Embedder.ready. Pure like state(): never starts, connects or spawns anything. */
+  ready(ms) {
+    if (this.st.state === "ready") return Promise.resolve(true);
+    if (this.st.state !== "preparing" || !(ms > 0)) return Promise.resolve(false);
+    return new Promise((resolve) => {
+      let t;
+      const w = (ok) => {
+        clearTimeout(t);
+        this.readyWaiters.delete(w);
+        resolve(ok);
+      };
+      this.readyWaiters.add(w);
+      t = setTimeout(() => w(false), ms);
+    });
+  }
+  settleReady(ok) {
+    for (const w of [...this.readyWaiters]) w(ok);
+  }
   tcp() {
     return (this.o.platform ?? process.platform) === "win32";
   }
@@ -30074,6 +30098,24 @@ var EmbedderClient = class {
     for (const p of this.pending.values()) p.rej(new Error(reason));
     this.pending.clear();
     if (reason !== "verify_failed" && reason !== "embedder_crashed") this.notBefore = Math.max(this.notBefore, this.now() + reconnectDelayMs(++this.fails));
+    this.settleReady(false);
+  }
+  /**
+   * Rule 6, cold-path ruling (2026-10-09): the served socket closed. With no job pending and this client's last job (or
+   * its connect, if later) at least the shared idle constant ago, it is the shared embedder's idle stop, which is not a
+   * failure: back to `off`, no `fails++`, no `notBefore`, no unavailable report, so the next turn's ensureStarted starts
+   * it at once. Anything else (a job pending, or recent use) stays a failure with its backoff.
+   */
+  onServedClose() {
+    if (this.closed) return;
+    if (this.pending.size > 0 || this.now() - this.lastActivity < EMBEDDER_IDLE_MS) return this.fail("embedder_unavailable");
+    this.log("info", "memory.embedder_idle_closed");
+    this.st = { state: "off" };
+    const s = this.sock;
+    this.sock = null;
+    this.chan = null;
+    s?.destroy();
+    this.settleReady(false);
   }
   ensureStarted() {
     if (this.closed || this.st.state === "preparing" || this.st.state === "ready") return;
@@ -30285,9 +30327,11 @@ var EmbedderClient = class {
           this.st = { state: "ready" };
           this.fails = 0;
           this.starts = [];
+          this.lastActivity = this.now();
           s.on("close", () => {
-            if (this.sock === s) this.fail("embedder_unavailable");
+            if (this.sock === s) this.onServedClose();
           });
+          this.settleReady(true);
           done(true);
         } catch {
           refuse("embedder_unavailable");
@@ -30321,6 +30365,7 @@ var EmbedderClient = class {
     const id = ++this.seq;
     const s = this.sock;
     const chan = this.chan;
+    this.lastActivity = this.now();
     return new Promise((res, rej) => {
       const signal = opts.signal;
       const onAbort = () => {
@@ -30349,6 +30394,7 @@ var EmbedderClient = class {
     for (const p of this.pending.values()) p.rej(new Error("closed"));
     this.pending.clear();
     this.st = { state: "off" };
+    this.settleReady(false);
   }
 };
 
@@ -30369,6 +30415,8 @@ function rankRecall(query, cache, o) {
 
 // src/memory/recall/recall-book.ts
 var DIMS = 384;
+var RECALL_QUERY_TIMEOUT_TEXT_MS = 600;
+var RECALL_QUERY_TIMEOUT_VOICE_MS = 250;
 var RecallBook = class _RecallBook {
   constructor(d) {
     this.d = d;
@@ -30422,10 +30470,12 @@ var RecallBook = class _RecallBook {
   static IDLE_MS = 30 * 6e4;
   static TOP_K = 5;
   static TEXT_MAX_CHARS = 2e3;
-  static QUERY_TIMEOUT_MS = 150;
+  /** About 1.5 ms of real opens at the measured ~40 µs per row: the longest a warm holds the event loop. */
+  static WARM_YIELD_ROWS = 32;
   caches = /* @__PURE__ */ new Map();
   entries = /* @__PURE__ */ new Map();
-  warming = /* @__PURE__ */ new Set();
+  /** The warm in flight per conversation: a cold turn awaits the same warm instead of starting a second one. */
+  warming = /* @__PURE__ */ new Map();
   same(a, b) {
     return a.clearGeneration === b.clearGeneration && a.modeEpoch === b.modeEpoch && a.purgeEpoch === b.purgeEpoch && a.contentEpoch === b.contentEpoch;
   }
@@ -30435,6 +30485,15 @@ var RecallBook = class _RecallBook {
   cacheWarm(conversationId) {
     return this.caches.has(conversationId);
   }
+  /**
+   * Task 27 Step 1: the bytes the warm vector caches hold (a number, content-free; /healthz `recall_cache_bytes`).
+   * The backing buffer, not the view: a warm that skipped unreadable rows installs a shorter view of a full buffer.
+   */
+  cacheBytes() {
+    let n = 0;
+    for (const c of this.caches.values()) n += c.vecs.buffer.byteLength;
+    return n;
+  }
   /**
    * §7.3 (H2): snapshot first, open outside the mutex, install under it. Never on a turn's path. Never rejects:
    * a read failure leaves the cache cold (fail closed: no recall).
@@ -30450,15 +30509,23 @@ var RecallBook = class _RecallBook {
    *     re-read rows (ids gone are dropped, the few new ids are opened here, under the mutex) and installed with the
    *     re-read capture.
    */
-  async warm(conversationId) {
-    if (this.warming.has(conversationId)) return;
-    this.warming.add(conversationId);
+  warm(conversationId) {
+    const inFlight = this.warming.get(conversationId);
+    if (inFlight) return inFlight;
+    const w = this.warmOnce(conversationId).finally(() => {
+      if (this.warming.get(conversationId) === w) this.warming.delete(conversationId);
+    });
+    this.warming.set(conversationId, w);
+    return w;
+  }
+  async warmOnce(conversationId) {
     try {
       const snap = this.d.store.readRecallRows(conversationId);
       const rows = snap.rows.filter((r) => r.modelId === this.d.modelId);
       const opened = /* @__PURE__ */ new Map();
       const failed = /* @__PURE__ */ new Set();
-      for (const r of rows) {
+      for (const [i, r] of rows.entries()) {
+        if (i > 0 && i % _RecallBook.WARM_YIELD_ROWS === 0) await new Promise((r2) => setImmediate(r2));
         const v = await this.d.store.openRecallVec(conversationId, r);
         if (!v || v.length !== DIMS) {
           failed.add(r.recallId);
@@ -30500,46 +30567,61 @@ var RecallBook = class _RecallBook {
       if (unreadable > 0) (this.d.log ?? writeServiceLog2)("warn", "memory.recall_open_failed", { count: unreadable });
     } catch (e) {
       (this.d.log ?? writeServiceLog2)("warn", "memory.recall_warm_failed", {}, e);
-    } finally {
-      this.warming.delete(conversationId);
     }
   }
   /**
    * §7.1: compute at ingest. Snapshot the capture FIRST (H2); `receipt`
    * replaces its purge and mode epochs with the ones captured when the turn
    * was received (Task 16 fix H-2), so a purge or a mode change after receipt
-   * refuses too. 150 ms bound on the query embed; a cold cache starts a warm
-   * and gives nothing.
+   * refuses too.
+   *
+   * Cold-path ruling (architect, 2026-10-09; §7.1 and §7.3 errata): ONE deadline, start + `timeoutMs` (the caller
+   * passes its turn kind's bound: 600 ms text, 250 ms voice), covers the ready wait, the warm and the query embed
+   * together; no phase has a budget of its own. A cold embedder is started (ensureStarted) and waited for; a cold or
+   * stale cache is warmed and waited for. Past the deadline there is no recall and nothing attaches late: a warm that
+   * outlives it keeps running and may install (warm enforces H2 itself), but this turn gets no entry.
    */
   async prepare(p) {
     const fresh = this.d.store.recallCapture(p.conversationId);
     const capture = p.receipt ? { ...fresh, purgeEpoch: p.receipt.purgeEpoch, modeEpoch: p.receipt.modeEpoch } : fresh;
     this.entries.delete(p.messageId);
-    const now = this.nowMs();
-    this.dropIdleCaches(now);
-    if (this.d.embedder.state().state !== "ready") {
-      this.d.embedder.ensureStarted();
-      return;
-    }
-    const cache = this.caches.get(p.conversationId);
-    if (!cache || !this.same(cache.capture, capture)) {
-      void this.warm(p.conversationId);
-      return;
-    }
+    this.dropIdleCaches(this.nowMs());
+    const deadlineAt = Date.now() + p.timeoutMs;
     const ac = new AbortController();
+    let late = false;
     let timer;
-    const q = await Promise.race([
-      this.d.embedder.embed(p.query, 0, { signal: ac.signal }).catch(() => null),
-      new Promise((r) => {
-        timer = setTimeout(() => {
-          ac.abort();
-          r(null);
-        }, p.timeoutMs ?? _RecallBook.QUERY_TIMEOUT_MS);
-      })
-    ]);
-    clearTimeout(timer);
-    if (!q || q.length !== DIMS) return;
-    cache.lastUse = this.nowMs();
+    const expired = new Promise((r) => {
+      timer = setTimeout(() => {
+        late = true;
+        ac.abort();
+        r("expired");
+      }, p.timeoutMs);
+    });
+    try {
+      if (this.d.embedder.state().state !== "ready") {
+        this.d.embedder.ensureStarted();
+        if (await Promise.race([this.d.embedder.ready(Math.max(0, deadlineAt - Date.now())).catch(() => false), expired]) !== true) return;
+      }
+      let cache = this.caches.get(p.conversationId);
+      if (!cache || !this.same(cache.capture, capture)) {
+        const cur = this.d.store.recallCapture(p.conversationId);
+        if (cur.clearGeneration !== capture.clearGeneration || cur.modeEpoch !== capture.modeEpoch || cur.purgeEpoch !== capture.purgeEpoch) return;
+        if (await Promise.race([this.warm(p.conversationId).then(() => "warmed"), expired]) !== "warmed") return;
+        cache = this.caches.get(p.conversationId);
+        if (!cache || !this.same(cache.capture, capture)) return;
+      }
+      cache.lastUse = this.nowMs();
+      const q = await Promise.race([
+        this.d.embedder.embed(p.query, 0, { signal: ac.signal }).catch(() => null),
+        expired.then(() => null)
+      ]);
+      if (!q || q.length !== DIMS) return;
+      await Promise.race([this.attach(p, capture, cache, q, () => late), expired]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async attach(p, capture, cache, q, late) {
     const ranked = rankRecall(
       q,
       { vecs: cache.vecs, dims: DIMS, messageIds: cache.messageIds, recallIds: cache.recallIds },
@@ -30561,7 +30643,7 @@ var RecallBook = class _RecallBook {
       items.push({ id: r.recallId, text, sent_at: row.sentAt });
     }
     if (unreadable > 0) (this.d.log ?? writeServiceLog2)("warn", "memory.recall_open_failed", { count: unreadable });
-    if (items.length === 0) return;
+    if (items.length === 0 || late()) return;
     if (this.entries.size >= _RecallBook.MAP_MAX) this.entries.delete(this.entries.keys().next().value);
     this.entries.set(p.messageId, { conversationId: p.conversationId, capture, items });
   }
@@ -32897,6 +32979,19 @@ var BridgeAgent = class _BridgeAgent {
   recallStageEpochs = /* @__PURE__ */ new Map();
   /** 7b Task 16: in-flight fire-and-forget index taps; close() waits for them (bounded). */
   recallTapWork = /* @__PURE__ */ new Set();
+  /**
+   * §13.5 live check (2026-10-09, cold start): set when an apply turns recall on (the boot apply included), cleared
+   * once the maintenance tick has started the DM prewarm, or when recall is off at a tick.
+   */
+  recallPrewarmPending = false;
+  /** The DM prewarm in flight (one at a time); close() waits for it (bounded). */
+  recallPrewarmWork = null;
+  /**
+   * Cold-path ruling B (2026-10-09): conversations whose turn passed Q1/Q2, for the maintenance tick to warm once the
+   * embedder is ready (runRecallPrewarm). Bounded; dropped whenever a tick finds recall off.
+   */
+  recallPrewarmTargets = /* @__PURE__ */ new Set();
+  static RECALL_PREWARM_TARGETS_MAX = 256;
   /**
    * Final-review item 2: conversations whose `audience` skip was already logged in this process. A room (or any
    * conversation the owner-DM gate refuses) refuses every turn the same way, so the line is written once per
@@ -35096,7 +35191,9 @@ var BridgeAgent = class _BridgeAgent {
         await this.notes.exclusive(async () => {
           if (this.store.applyRecallMode("semantic", mem.recallDays).purged > 0) this.onRecallRetentionChangedLocked();
         });
+        const turnedOn = !this.recallConfig.on;
         this.recallConfig = { on: true };
+        if (turnedOn) this.armRecallPrewarm();
         if (this.cfg.modelSource === "download" && !this.modelDownloadNoticeLogged) {
           this.modelDownloadNoticeLogged = true;
           writeServiceLog2("info", "memory.model_download_enabled");
@@ -35117,6 +35214,59 @@ var BridgeAgent = class _BridgeAgent {
       writeServiceLog2("warn", "memory.recall_mode_failed", {}, e);
     }
   }
+  /**
+   * §13.5 live check (2026-10-09, cold start). After a restart in semantic mode turn 1 got no recall (the embedder
+   * was not ready: ensureStarted, return) and turn 2 none either (no cache: a background warm, return). So when an
+   * apply turns recall on (the boot apply included) and the model files are on disk, the embedder is started here,
+   * off the turn path; the
+   * maintenance tick warms the DM caches once it is ready (runRecallPrewarm). Synchronous and never throws:
+   * ensureStarted only schedules the start, so boot never waits for it.
+   */
+  armRecallPrewarm() {
+    try {
+      if (!this.recallProviderOn()) return;
+      if (!this.embedder.filesPresent()) return;
+      this.recallPrewarmPending = true;
+      this.embedder.ensureStarted();
+    } catch (e) {
+      writeServiceLog2("warn", "memory.recall_prewarm_failed", {}, e);
+    }
+  }
+  /**
+   * The maintenance tick's half of the cold-start prewarm: once the embedder is ready (no cache RAM is spent on an
+   * embedder that may never come up), warm each DM conversation, one at a time, detached from the tick. DM is the
+   * persisted is_dm === true, the rule the membership sweep uses (audit r1 M6); a vault channel is never one. The
+   * prewarm only opens vectors through RecallBook.warm, which snapshots the capture first and installs nothing
+   * across a clear, a mode change or a purge (H2, M-A3). It indexes nothing and prepares nothing. Recall turned off
+   * before or during it stops it (I1, Q1). Never throws.
+   */
+  runRecallPrewarm() {
+    if (!this.recallPrewarmPending && this.recallPrewarmTargets.size === 0 || this.recallPrewarmWork || this.closingDown) return;
+    if (this.embedder.state().state !== "ready") return;
+    const all = this.recallPrewarmPending;
+    this.recallPrewarmPending = false;
+    const targets = [...this.recallPrewarmTargets];
+    this.recallPrewarmTargets.clear();
+    this.recallPrewarmWork = (async () => {
+      try {
+        const isDm = (c) => !this.vaultChannelIds.has(c) && this.store.getChannelMeta(c)?.isDm === true;
+        const dms = [.../* @__PURE__ */ new Set([...targets, ...all ? this.store.memoryConversationIds() : []])].filter(isDm);
+        for (const c of dms) {
+          if (this.closingDown || !this.recallProviderOn()) return;
+          if (this.recall.cacheWarm(c)) continue;
+          await this.recall.warm(c);
+        }
+      } catch (e) {
+        writeServiceLog2("warn", "memory.recall_prewarm_failed", {}, e);
+      }
+    })().finally(() => {
+      this.recallPrewarmWork = null;
+    });
+  }
+  /** @internal test seam: resolves once the DM prewarm in flight, if any, has settled. */
+  async settleRecallPrewarm() {
+    await this.recallPrewarmWork;
+  }
   /** A retention change or a prune removed rows: drop the vector caches. Called only inside notes.exclusive. */
   onRecallRetentionChangedLocked() {
     this.recall.dropAllCachesLocked();
@@ -35126,8 +35276,8 @@ var BridgeAgent = class _BridgeAgent {
     this.recall.dropAllLocked();
   }
   /**
-   * 7b spec §7.1, §7.2: Q1 (config half) and Q2 here, then the 150 ms bound
-   * inside RecallBook.prepare. Called beside prepareNotesForTurn, before the
+   * 7b spec §7.1, §7.2: Q1 (config half) and Q2 here, then the turn kind's
+   * bound inside RecallBook.prepare (600 ms text, 250 ms voice; ruling 2026-10-09). Called beside prepareNotesForTurn, before the
    * turn is staged. The receipt epochs (Task 16 fix H-2) narrow the capture:
    * the in-cycle receipt, else the persisted staging marks; marks that exist
    * but lack an epoch give no recall (fail closed). Never throws.
@@ -35135,11 +35285,13 @@ var BridgeAgent = class _BridgeAgent {
   async prepareRecallForTurn(t) {
     try {
       if (!this.recallProviderOn() || !this.notesReadable(t.authorization)) return;
+      if (this.recallPrewarmTargets.size < _BridgeAgent.RECALL_PREWARM_TARGETS_MAX) this.recallPrewarmTargets.add(t.channelId);
       const marks = this.recallReceipt.get(t.messageId) ?? this.recallStageEpochs.get(t.messageId);
       if (marks !== void 0 && (marks.purgeEpoch === void 0 || marks.modeEpoch === void 0)) return;
       const receipt = marks === void 0 ? void 0 : { purgeEpoch: marks.purgeEpoch, modeEpoch: marks.modeEpoch };
       const exclude = this.store.recentMemoryMessageIds(t.channelId, 50);
-      await this.recall.prepare({ messageId: t.messageId, conversationId: t.channelId, query: t.text, excludeIds: exclude, ...receipt ? { receipt } : {} });
+      const timeoutMs = t.kind === "voice" ? RECALL_QUERY_TIMEOUT_VOICE_MS : RECALL_QUERY_TIMEOUT_TEXT_MS;
+      await this.recall.prepare({ messageId: t.messageId, conversationId: t.channelId, query: t.text, excludeIds: exclude, timeoutMs, ...receipt ? { receipt } : {} });
     } catch (e) {
       writeServiceLog2("warn", "memory.recall_prepare_failed", {}, e);
     }
@@ -35301,8 +35453,11 @@ var BridgeAgent = class _BridgeAgent {
     }
     if (!this.recallProviderOn()) {
       this.reembedHot = false;
+      this.recallPrewarmPending = false;
+      this.recallPrewarmTargets.clear();
       return;
     }
+    this.runRecallPrewarm();
     if (!this.reembedHot && n % 60 !== 0) return;
     try {
       this.reembedHot = await this.reembed.tick() > 0;
@@ -37094,7 +37249,10 @@ var BridgeAgent = class _BridgeAgent {
             const turnText = parsed.text;
             const isCallStart = turnText.trim() === VOICE_CALL_START_MARKER;
             const coalescible = this.voiceCoalesceWindowMs > 0 && m.voiceMode === true && speaker !== void 0 && parsed.transcribed === true && voiceGuidance !== void 0 && !isCallStart;
-            if (!coalescible) await this.prepareRecallForTurn({ channelId: m.channelId, messageId: m.messageId, text: parsed.text, authorization: turnAuthorization });
+            if (!coalescible) {
+              const kind2 = m.voiceMode === true || parsed.transcribed === true ? "voice" : "text";
+              await this.prepareRecallForTurn({ channelId: m.channelId, messageId: m.messageId, text: parsed.text, authorization: turnAuthorization, kind: kind2 });
+            }
             let fastPathRoomBlocked = false;
             if (!coalescible && fastPathEligible && meta && meta.is_dm === false) {
               const reserved = this.fastReplyReserved.get(m.channelId) ?? 0;
@@ -37178,7 +37336,7 @@ var BridgeAgent = class _BridgeAgent {
                 const [firstId, ...tailIds] = win.ids;
                 if (tailIds.length) this.voiceCoalescedTails.set(firstId, tailIds);
                 const text = win.parts.join(" ");
-                await this.prepareRecallForTurn({ channelId, messageId: firstId, text, authorization: turnAuthorization });
+                await this.prepareRecallForTurn({ channelId, messageId: firstId, text, authorization: turnAuthorization, kind: "voice" });
                 const merged = { ...held, text };
                 void recordInboundMemory(this.memory, channelId, senderId, text, firstId, "voice", win.purgeEpoch);
                 let roomBlocked = false;
@@ -37924,6 +38082,7 @@ var BridgeAgent = class _BridgeAgent {
       retired_drained: this.provider.retiredDrainedCount(),
       // INV-CUSTODY-DURABLE §5.C.3: custody health.
       expired_drained: this.provider.expiredDrainedCount(),
+      recall_cache_bytes: this.recall.cacheBytes(),
       custody_persist_failing: this.provider.custodyHealth().persistFailing,
       custody_persist_failures: this.provider.custodyHealth().persistFailures,
       custody_read_failing: this.provider.custodyHealth().readFailing,
@@ -38057,6 +38216,16 @@ var BridgeAgent = class _BridgeAgent {
       ]);
       if (timer) clearTimeout(timer);
     }
+    if (this.recallPrewarmWork) {
+      let timer;
+      await Promise.race([
+        this.recallPrewarmWork,
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, _BridgeAgent.GRACEFUL_DRAIN_MS);
+        })
+      ]);
+      if (timer) clearTimeout(timer);
+    }
     this.embedder.close?.();
     if (this.replyWork.size) {
       let timer;

package/dist/memory/embedder/client.d.ts

@@ -16,6 +16,12 @@ export interface Embedder {
     state(): EmbedderState;
     ensureStarted(): void;
     filesPresent(): boolean;
+    /**
+     * Cold-path ruling (2026-10-09): true at once when ready; while preparing, true on the transition to ready and false
+     * on a failure, a stop or after `ms`. False at once in any other state. Never rejects and never starts, connects or
+     * spawns anything itself (the caller runs ensureStarted first).
+     */
+    ready(ms: number): Promise<boolean>;
     embed(text: string, priority: 0 | 1, opts?: {
         signal?: AbortSignal;
     }): Promise<Float32Array>;
@@ -64,12 +70,19 @@ export declare class EmbedderClient implements Embedder {
     private verifyAttempt;
     private fails;
     private closed;
+    /** When this client last sent a job (or connected, if later): the idle-stop test (cold-path ruling 2026-10-09). */
+    private lastActivity;
+    /** ready(ms) waiters: settled on the next transition out of "preparing". */
+    private readonly readyWaiters;
     private readonly m;
     private readonly now;
     private readonly log;
     constructor(o: EmbedderClientOptions);
     /** Pure: the report path reads this, and reading it never starts, connects or spawns anything (plan audit LOW). */
     state(): EmbedderState;
+    /** Cold-path ruling (2026-10-09): see Embedder.ready. Pure like state(): never starts, connects or spawns anything. */
+    ready(ms: number): Promise<boolean>;
+    private settleReady;
     private tcp;
     filesPresent(): boolean;
     private key;
@@ -87,6 +100,13 @@ export declare class EmbedderClient implements Embedder {
     private aclToken;
     private aclOk;
     private fail;
+    /**
+     * Rule 6, cold-path ruling (2026-10-09): the served socket closed. With no job pending and this client's last job (or
+     * its connect, if later) at least the shared idle constant ago, it is the shared embedder's idle stop, which is not a
+     * failure: back to `off`, no `fails++`, no `notBefore`, no unavailable report, so the next turn's ensureStarted starts
+     * it at once. Anything else (a job pending, or recent use) stays a failure with its backoff.
+     */
+    private onServedClose;
     ensureStarted(): void;
     private start;
     /** The embedder's fixed-code status file (exit 3). True when it decided the state. */

package/dist/memory/embedder/protocol.d.ts

@@ -1,6 +1,11 @@
 /** Spec §20 E1.2 to E1.4: newline-delimited JSON frames over the local socket; vectors as base64 little-endian float32. */
 export declare const EMBEDDER_PROTOCOL = 1;
 export declare const MAX_TEXT_BYTES = 8192;
+/**
+ * The shared embedder stops after this long with no job from any bridge (server `idleMs` default). The client uses the
+ * same value to tell that idle stop from a failure (cold-path ruling 2026-10-09): ONE constant, used by both.
+ */
+export declare const EMBEDDER_IDLE_MS: number;
 /**
  * 11b review M4: the longest sealed job line. Worst case for MAX_TEXT_BYTES of text: every byte a control character that
  * JSON escapes as \u00XX (6 bytes) = 49152, plus the frame's other fields (< 100), plus the 24-byte nonce and 16-byte

package/dist/memory/recall/recall-book.d.ts

@@ -9,6 +9,14 @@
 import type { RecallCapture, RecallRow, RuntimeInboxRewrite, SqliteMlsStateStore } from "@agentvault/connect-mls-store";
 import { type ServiceLog } from "../../service-log.js";
 import type { Embedder } from "../embedder/client.js";
+/**
+ * Spec §7.1, §20 E1.4 (architect ruling, owner-approved 2026-10-09): the per-turn-kind wall-clock bound on the
+ * query embed. A typed turn waits up to 600 ms; a coalesced voice turn at window close up to 250 ms. A result
+ * after the bound is discarded (fail closed: no recall), never attached late. The cutoff cancels the job at the
+ * shared embedder. Each kind's value is this one line.
+ */
+export declare const RECALL_QUERY_TIMEOUT_TEXT_MS = 600;
+export declare const RECALL_QUERY_TIMEOUT_VOICE_MS = 250;
 export type IndexSkip = "mode" | "audience" | "voice" | "length" | "secret" | "stamp_missing" | "cleared" | "epoch" | "purged" | "duplicate" | "store";
 export interface RecallTapCapture {
     readonly generation: number | undefined;
@@ -54,13 +62,20 @@ export declare class RecallBook {
     private static readonly IDLE_MS;
     private static readonly TOP_K;
     private static readonly TEXT_MAX_CHARS;
-    private static readonly QUERY_TIMEOUT_MS;
+    /** About 1.5 ms of real opens at the measured ~40 µs per row: the longest a warm holds the event loop. */
+    private static readonly WARM_YIELD_ROWS;
     private readonly caches;
     private readonly entries;
+    /** The warm in flight per conversation: a cold turn awaits the same warm instead of starting a second one. */
     private readonly warming;
     private same;
     private nowMs;
     cacheWarm(conversationId: string): boolean;
+    /**
+     * Task 27 Step 1: the bytes the warm vector caches hold (a number, content-free; /healthz `recall_cache_bytes`).
+     * The backing buffer, not the view: a warm that skipped unreadable rows installs a shorter view of a full buffer.
+     */
+    cacheBytes(): number;
     /**
      * §7.3 (H2): snapshot first, open outside the mutex, install under it. Never on a turn's path. Never rejects:
      * a read failure leaves the cache cold (fail closed: no recall).
@@ -77,24 +92,31 @@ export declare class RecallBook {
      *     re-read capture.
      */
     warm(conversationId: string): Promise<void>;
+    private warmOnce;
     /**
      * §7.1: compute at ingest. Snapshot the capture FIRST (H2); `receipt`
      * replaces its purge and mode epochs with the ones captured when the turn
      * was received (Task 16 fix H-2), so a purge or a mode change after receipt
-     * refuses too. 150 ms bound on the query embed; a cold cache starts a warm
-     * and gives nothing.
+     * refuses too.
+     *
+     * Cold-path ruling (architect, 2026-10-09; §7.1 and §7.3 errata): ONE deadline, start + `timeoutMs` (the caller
+     * passes its turn kind's bound: 600 ms text, 250 ms voice), covers the ready wait, the warm and the query embed
+     * together; no phase has a budget of its own. A cold embedder is started (ensureStarted) and waited for; a cold or
+     * stale cache is warmed and waited for. Past the deadline there is no recall and nothing attaches late: a warm that
+     * outlives it keeps running and may install (warm enforces H2 itself), but this turn gets no entry.
      */
     prepare(p: {
         messageId: string;
         conversationId: string;
         query: string;
         excludeIds: ReadonlySet<string>;
-        timeoutMs?: number;
+        timeoutMs: number;
         receipt?: {
             purgeEpoch: number;
             modeEpoch: number;
         };
     }): Promise<void>;
+    private attach;
     /** Q3 + Q6: the entry's own conversation, and its capture still current at delivery. Synchronous (ws flush). */
     deliverable(messageId: string, conversationId: string): readonly RecallItem[] | undefined;
     /**

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const BRIDGE_VERSION = "0.28.0";
+export declare const BRIDGE_VERSION = "0.28.2";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@securecoms/agent-bridge",
-  "version": "0.28.0",
+  "version": "0.28.2",
   "type": "module",
   "engines": {
     "node": ">=22.5.0"