@securecoms/agent-bridge 0.28.1 → 0.28.2

package/README.md

@@ -798,6 +798,22 @@ 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). -->

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);
   }
 };
 
@@ -30934,9 +30980,12 @@ var RecallBook = class _RecallBook {
   static IDLE_MS = 30 * 6e4;
   static TOP_K = 5;
   static TEXT_MAX_CHARS = 2e3;
+  /** 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;
   }
@@ -30970,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);
@@ -31020,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. `timeoutMs` bounds the query embed (the caller passes its turn kind's bound); 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;
-    }
-    cache.lastUse = now;
+    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);
-      })
-    ]);
-    clearTimeout(timer);
-    if (!q || q.length !== DIMS) return;
+    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 },
@@ -31081,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 });
   }
@@ -33164,6 +33236,12 @@ var BridgeAgent = class _BridgeAgent {
   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
@@ -35413,14 +35491,19 @@ var BridgeAgent = class _BridgeAgent {
    * before or during it stops it (I1, Q1). Never throws.
    */
   runRecallPrewarm() {
-    if (!this.recallPrewarmPending || this.recallPrewarmWork || this.closingDown) return;
+    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 dms = this.store.memoryConversationIds().filter((c) => !this.vaultChannelIds.has(c) && this.store.getChannelMeta(c)?.isDm === true);
+        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) {
@@ -35452,6 +35535,7 @@ 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 };
@@ -35620,6 +35704,7 @@ var BridgeAgent = class _BridgeAgent {
     if (!this.recallProviderOn()) {
       this.reembedHot = false;
       this.recallPrewarmPending = false;
+      this.recallPrewarmTargets.clear();
       return;
     }
     this.runRecallPrewarm();

package/dist/bridge-agent.d.ts

@@ -1199,6 +1199,12 @@ export declare class BridgeAgent {
     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

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);
   }
 };
 
@@ -30424,9 +30470,12 @@ var RecallBook = class _RecallBook {
   static IDLE_MS = 30 * 6e4;
   static TOP_K = 5;
   static TEXT_MAX_CHARS = 2e3;
+  /** 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;
   }
@@ -30460,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);
@@ -30510,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. `timeoutMs` bounds the query embed (the caller passes its turn kind's bound); 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;
-    }
-    cache.lastUse = now;
+    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);
-      })
-    ]);
-    clearTimeout(timer);
-    if (!q || q.length !== DIMS) return;
+    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 },
@@ -30571,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 });
   }
@@ -32914,6 +32986,12 @@ var BridgeAgent = class _BridgeAgent {
   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
@@ -35163,14 +35241,19 @@ var BridgeAgent = class _BridgeAgent {
    * before or during it stops it (I1, Q1). Never throws.
    */
   runRecallPrewarm() {
-    if (!this.recallPrewarmPending || this.recallPrewarmWork || this.closingDown) return;
+    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 dms = this.store.memoryConversationIds().filter((c) => !this.vaultChannelIds.has(c) && this.store.getChannelMeta(c)?.isDm === true);
+        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) {
@@ -35202,6 +35285,7 @@ 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 };
@@ -35370,6 +35454,7 @@ var BridgeAgent = class _BridgeAgent {
     if (!this.recallProviderOn()) {
       this.reembedHot = false;
       this.recallPrewarmPending = false;
+      this.recallPrewarmTargets.clear();
       return;
     }
     this.runRecallPrewarm();

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

@@ -62,8 +62,11 @@ export declare class RecallBook {
     private static readonly IDLE_MS;
     private static readonly TOP_K;
     private static readonly TEXT_MAX_CHARS;
+    /** 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;
@@ -89,12 +92,18 @@ 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. `timeoutMs` bounds the query embed (the caller passes its turn kind's bound); 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;
@@ -107,6 +116,7 @@ export declare class RecallBook {
             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.1";
+export declare const BRIDGE_VERSION = "0.28.2";

package/package.json

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