@securecoms/agent-bridge 0.28.2 → 0.29.0

package/dist/memory/unified/worker-protocol.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Unified memory (spec section 8.5, H-7, T-33): the messages between the bridge and its ranking worker. Only ids, scores and
+ * the opened texts of the items selected for a turn cross back. No message type FROM the worker carries a vector or a
+ * raw sealed buffer (worker-protocol.arch.test.ts, Task 14). The query vector goes TO the worker.
+ */
+import type { ItemKind, ItemSource, ItemTrust, ScopeKind } from "@agentvault/connect-mls-store/memory-items";
+export interface WorkerInit {
+    dbPath: string;
+    identityId: string;
+    storeKey: Uint8Array;
+    modelId: string;
+    threshold: number;
+    warm: boolean;
+    /** Plan Task 35, the recall eval only: replaces OWNER_SCOPE_PRIOR / RECENCY_SLOPE (0.05 since U1-G). Production never sets them (worker-protocol.arch.test.ts). */
+    priorOverride?: number;
+    recencySlopeOverride?: number;
+}
+export interface RankQuery {
+    scopes: string[];
+    ownerScope: string | null;
+    vec: Float32Array | null;
+    macs: Uint8Array[];
+    historyConversation: string;
+    currentMessageId: string;
+    maxItems: number;
+    maxChars: number;
+    nowMs: number;
+    excludeOriginIds: string[];
+}
+export interface OpenedItem {
+    itemId: number;
+    scopeKind: ScopeKind;
+    scopeId: string;
+    channelId: string;
+    kind: ItemKind;
+    originId: string;
+    originAt: number;
+    source: ItemSource;
+    trust: ItemTrust;
+    text: string;
+}
+export type ToWorker = {
+    type: "query";
+    id: number;
+    q: RankQuery;
+} | {
+    type: "pins";
+    id: number;
+    scopeId: string;
+    maxChars: number;
+} | {
+    type: "pending";
+    id: number;
+    limit: number;
+} | {
+    type: "added";
+    itemIds: number[];
+} | {
+    type: "removed";
+    itemIds: number[];
+} | {
+    type: "reset";
+};
+export type FromWorker = {
+    type: "ready";
+    hot: number;
+    hotBytes: number;
+} | {
+    type: "result";
+    id: number;
+    items: OpenedItem[];
+    openFailed: number;
+} | {
+    type: "pins";
+    id: number;
+    pins: OpenedItem[];
+    more: number;
+    openFailed: number;
+} | {
+    type: "pending";
+    id: number;
+    rows: Array<{
+        itemId: number;
+        channelId: string;
+        scopeKind: ScopeKind;
+        scopeId: string;
+        originId: string;
+        chunkIndex: number;
+        text: string;
+    }>;
+} | {
+    type: "stats";
+    hot: number;
+    hotBytes: number;
+}
+/** Final review bridge M-4: a request whose handler threw; the client answers it `failed` (a miss), the worker lives on. */
+ | {
+    type: "failed";
+    id: number;
+} | {
+    type: "fatal";
+};

package/dist/memory-worker.js

@@ -0,0 +1,583 @@
+// src/memory/unified/ranking-worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+import { DatabaseSync } from "node:sqlite";
+
+// ../connect-core/dist/envelope/aead.js
+import { gcm } from "@noble/ciphers/aes";
+import { xchacha20poly1305 } from "@noble/ciphers/chacha";
+import { randomBytes } from "@noble/hashes/utils";
+
+// ../../node_modules/@agentvault/crypto/dist/chunk-FCTZTCBV.js
+var ENCODER = new TextEncoder();
+
+// ../connect-core/dist/base64.js
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var LOOKUP = (() => {
+  const t = new Int16Array(256).fill(-1);
+  for (let i = 0; i < ALPHABET.length; i++)
+    t[ALPHABET.charCodeAt(i)] = i;
+  return t;
+})();
+
+// ../connect-core/dist/envelope/aead.js
+var APPLICATION_KEY_BYTES = 32;
+var NONCE_BYTES = {
+  xchacha20poly1305: 24,
+  aes256gcm: 12
+};
+function cipherFor(suite, key, nonce, aad) {
+  return suite === "aes256gcm" ? gcm(key, nonce, aad) : xchacha20poly1305(key, nonce, aad);
+}
+function assertKey(key) {
+  if (key.length !== APPLICATION_KEY_BYTES) {
+    throw new Error(`application key must be ${APPLICATION_KEY_BYTES} bytes (the MLS exporter output); got ${key.length}`);
+  }
+}
+function openPayload(p) {
+  assertKey(p.key);
+  const nlen = NONCE_BYTES[p.suite];
+  if (p.ciphertext.length < nlen) {
+    throw new Error("openPayload: ciphertext shorter than the AEAD nonce");
+  }
+  const nonce = p.ciphertext.subarray(0, nlen);
+  const body = p.ciphertext.subarray(nlen);
+  return cipherFor(p.suite, p.key, nonce, p.associatedData).decrypt(body);
+}
+
+// ../connect-mls-store/dist/memory-recall.js
+var RECALL_MAX_DIMS = 1024;
+var enc = new TextEncoder();
+function decodeVec(b) {
+  if (b.length === 0 || b.length % 4 !== 0 || b.length / 4 > RECALL_MAX_DIMS)
+    return null;
+  const dv = new DataView(b.buffer, b.byteOffset, b.length);
+  const out = new Float32Array(b.length / 4);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = dv.getFloat32(i * 4, true);
+    if (!Number.isFinite(out[i]))
+      return null;
+  }
+  return out;
+}
+var RECALL_FUTURE_SKEW_MS = 5 * 60 * 1e3;
+var W9_SPENT_HORIZON_MS = 7 * 24 * 60 * 60 * 1e3;
+
+// ../connect-mls-store/dist/memory-items.js
+var ITEM_SOURCES = [
+  "owner_typed",
+  "owner_voice",
+  "agent_reply",
+  "owner_pin",
+  "migrated_note",
+  "migrated_recall",
+  "imported_history",
+  "room_member",
+  "room_voice",
+  "person",
+  "file",
+  "room_transcript"
+];
+var OWNER_CAPABLE_SOURCES = /* @__PURE__ */ new Set(["owner_typed", "owner_voice", "owner_pin", "migrated_note", "migrated_recall"]);
+var ITEM_CAP_DEFAULT = 1e5;
+var BYTE_CAP_DEFAULT = 2 * 1024 * 1024 * 1024;
+var ITEM_ROW_OVERHEAD_BYTES = Math.max(48, 2388);
+var TOKEN_ROW_OVERHEAD_BYTES = Math.max(48, 180);
+var NUL = "\0";
+var enc2 = new TextEncoder();
+var noNul = (v, what) => {
+  if (v.includes(NUL))
+    throw new RangeError(`${what} holds a NUL`);
+};
+function parseOwnerDmScopeId(scopeId) {
+  const parts = scopeId.split(NUL);
+  return parts.length === 2 && parts[0] && parts[1] ? { channelId: parts[0], ownerIdentityId: parts[1] } : null;
+}
+function assertScope(kind, scopeId) {
+  if (kind === "owner_dm") {
+    if (parseOwnerDmScopeId(scopeId) === null)
+      throw new RangeError("owner_dm scope id must be channel\u20160\u2016owner");
+  } else
+    noNul(scopeId, "scope id");
+}
+function assertFields(identityId, f) {
+  noNul(identityId, "identity id");
+  noNul(f.channelId, "channel id");
+  noNul(f.originId, "origin id");
+  noNul(f.parentOriginId, "parent origin id");
+  assertScope(f.scopeKind, f.scopeId);
+  if (!Number.isSafeInteger(f.chunkIndex) || f.chunkIndex < 0)
+    throw new RangeError("chunk index");
+  if (!Number.isSafeInteger(f.originAt) || !Number.isSafeInteger(f.storedAt))
+    throw new RangeError("timestamps");
+  const chunk = f.chunkIndex > 0;
+  if (chunk !== (f.parentId !== null) || chunk !== (f.parentOriginId !== ""))
+    throw new RangeError("parent fields must be set exactly for a chunk");
+  if (f.parentId !== null && (!Number.isSafeInteger(f.parentId) || f.parentId < 1))
+    throw new RangeError("parent id");
+}
+function itemRecordAad(identityId, f) {
+  assertFields(identityId, f);
+  return enc2.encode([
+    "agent_memory_item",
+    identityId,
+    f.scopeKind,
+    f.scopeId,
+    f.channelId,
+    f.kind,
+    f.originId,
+    String(f.chunkIndex),
+    f.parentOriginId,
+    f.parentId === null ? "" : String(f.parentId),
+    String(f.originAt),
+    String(f.storedAt)
+  ].join(NUL));
+}
+function itemVecAad(identityId, f, modelId) {
+  noNul(identityId, "identity id");
+  noNul(f.originId, "origin id");
+  noNul(modelId, "model id");
+  assertScope(f.scopeKind, f.scopeId);
+  if (!Number.isSafeInteger(f.chunkIndex) || f.chunkIndex < 0)
+    throw new RangeError("chunk index");
+  return enc2.encode(["agent_memory_item_vec", identityId, f.scopeKind, f.scopeId, f.originId, String(f.chunkIndex), modelId].join(NUL));
+}
+function decodeItemRecord(b) {
+  let o;
+  try {
+    o = JSON.parse(new TextDecoder().decode(b));
+  } catch {
+    return null;
+  }
+  if (!o || typeof o !== "object" || Array.isArray(o))
+    return null;
+  const { v, t, s, tr, sr, c } = o;
+  if (v !== 1 || typeof t !== "string" || typeof s !== "string" || !ITEM_SOURCES.includes(s))
+    return null;
+  if (tr !== "owner" && tr !== "reference")
+    return null;
+  if (tr === "owner" && !OWNER_CAPABLE_SOURCES.has(s))
+    return null;
+  if (sr !== void 0 && typeof sr !== "string")
+    return null;
+  if (c !== void 0 && (typeof c !== "number" || !Number.isSafeInteger(c) || c < 1))
+    return null;
+  return { text: t, source: s, trust: tr, ...sr !== void 0 ? { sourceRef: sr } : {}, ...c !== void 0 ? { chunks: c } : {} };
+}
+
+// src/memory/unified/ranking-core.ts
+var DIMS = 384;
+var OWNER_SCOPE_PRIOR = 0.05;
+var RECENCY_FLOOR = 0.85;
+var RECENCY_SLOPE = 0.05;
+var RRF_K = 60;
+var HOT_TOKEN_MAX_POSTINGS = 5e3;
+var LIST_MAX = 50;
+var FRESHNESS_TIE_EPSILON = 1e-12;
+var HOT_SET_HEADROOM = 1024;
+var HOT_SET_GROWTH = 1.25;
+var DAY_MS = 864e5;
+function recencyWeight(ageDays, slope = RECENCY_SLOPE) {
+  return Math.max(RECENCY_FLOOR, 1 - Math.max(0, ageDays) / 365 * slope);
+}
+function hotSetReserve(embeddedCount) {
+  return Math.min(Math.max(0, embeddedCount), ITEM_CAP_DEFAULT) + HOT_SET_HEADROOM;
+}
+function hotSetGrowth(cap, need) {
+  let next = Math.min(Math.ceil(cap * HOT_SET_GROWTH), ITEM_CAP_DEFAULT);
+  if (next <= cap) next = cap + HOT_SET_HEADROOM;
+  return Math.max(need, next, HOT_SET_HEADROOM);
+}
+var HotSet = class {
+  cap = 0;
+  n = 0;
+  q = new Int8Array(0);
+  scale = new Float32Array(0);
+  ids = new Float64Array(0);
+  at = new Float64Array(0);
+  scopeOf = new Int32Array(0);
+  pin = new Uint8Array(0);
+  slotOf = /* @__PURE__ */ new Map();
+  scopes = [];
+  scopeIdx = /* @__PURE__ */ new Map();
+  get size() {
+    return this.n;
+  }
+  get capacity() {
+    return this.cap;
+  }
+  vectorBytes() {
+    return this.n * DIMS;
+  }
+  bytes() {
+    return this.q.byteLength + this.scale.byteLength + this.ids.byteLength + this.at.byteLength + this.scopeOf.byteLength + this.pin.byteLength;
+  }
+  /** U1-G (D): sets the capacity to at least `slots` in one allocation (the warm reserve). */
+  reserve(slots) {
+    if (slots > this.cap) this.resize(slots);
+  }
+  grow(min) {
+    if (min > this.cap) this.resize(hotSetGrowth(this.cap, min));
+  }
+  /** The old buffers are dropped (unreferenced) as soon as they are copied. */
+  resize(cap) {
+    const q = new Int8Array(cap * DIMS);
+    q.set(this.q);
+    this.q = q;
+    const sc = new Float32Array(cap);
+    sc.set(this.scale);
+    this.scale = sc;
+    const ids = new Float64Array(cap);
+    ids.set(this.ids);
+    this.ids = ids;
+    const at = new Float64Array(cap);
+    at.set(this.at);
+    this.at = at;
+    const so = new Int32Array(cap);
+    so.set(this.scopeOf);
+    this.scopeOf = so;
+    const p = new Uint8Array(cap);
+    p.set(this.pin);
+    this.pin = p;
+    this.cap = cap;
+  }
+  add(e) {
+    if (e.vec.length !== DIMS) return;
+    let slot = this.slotOf.get(e.itemId);
+    if (slot === void 0) {
+      this.grow(this.n + 1);
+      slot = this.n++;
+      this.slotOf.set(e.itemId, slot);
+    }
+    let m = 0;
+    for (const x of e.vec) m = Math.max(m, Math.abs(x));
+    const s = m > 0 ? m / 127 : 1;
+    for (let i = 0; i < DIMS; i++) this.q[slot * DIMS + i] = Math.round(e.vec[i] / s);
+    let si = this.scopeIdx.get(e.scopeId);
+    if (si === void 0) {
+      si = this.scopes.length;
+      this.scopes.push(e.scopeId);
+      this.scopeIdx.set(e.scopeId, si);
+    }
+    this.scale[slot] = s;
+    this.ids[slot] = e.itemId;
+    this.at[slot] = e.originAt;
+    this.scopeOf[slot] = si;
+    this.pin[slot] = e.pinned ? 1 : 0;
+  }
+  remove(itemId) {
+    const slot = this.slotOf.get(itemId);
+    if (slot === void 0) return;
+    const last = this.n - 1;
+    if (slot !== last) {
+      this.q.copyWithin(slot * DIMS, last * DIMS, (last + 1) * DIMS);
+      this.scale[slot] = this.scale[last];
+      this.ids[slot] = this.ids[last];
+      this.at[slot] = this.at[last];
+      this.scopeOf[slot] = this.scopeOf[last];
+      this.pin[slot] = this.pin[last];
+      this.slotOf.set(this.ids[slot], slot);
+    }
+    this.slotOf.delete(itemId);
+    this.n--;
+  }
+  clear() {
+    this.n = 0;
+    this.slotOf.clear();
+  }
+  /** section 8.5: sim (int8 dot x scale), meaning threshold, then (sim + prior) x recency; the top `k` by that score. */
+  topK(query, allowed, o) {
+    const ok = new Uint8Array(this.scopes.length);
+    this.scopes.forEach((s, i) => {
+      ok[i] = allowed.has(s) ? 1 : 0;
+    });
+    const owner = o.ownerScope === null ? -1 : this.scopeIdx.get(o.ownerScope) ?? -2;
+    const top = [];
+    for (let slot = 0; slot < this.n; slot++) {
+      const si = this.scopeOf[slot];
+      if (!ok[si]) continue;
+      let dot = 0;
+      const base = slot * DIMS;
+      for (let i = 0; i < DIMS; i++) dot += this.q[base + i] * query[i];
+      const sim = dot * this.scale[slot];
+      if (sim < o.threshold) continue;
+      const prior = si === owner || this.pin[slot] === 1 ? o.prior ?? OWNER_SCOPE_PRIOR : 0;
+      const score = (sim + prior) * recencyWeight((o.nowMs - this.at[slot]) / DAY_MS, o.recencySlope);
+      if (top.length < o.k) {
+        top.push({ itemId: this.ids[slot], sim, score });
+        top.sort((a, b) => a.score - b.score);
+      } else if (score > top[0].score) {
+        top[0] = { itemId: this.ids[slot], sim, score };
+        top.sort((a, b) => a.score - b.score);
+      }
+    }
+    return top.reverse();
+  }
+};
+var UTF8 = new TextDecoder();
+var SCOPE_B = "CAST(i.scope_id AS BLOB) AS scope_id_b";
+function fixScope(r) {
+  if (r && r.scope_id_b) r.scope_id = UTF8.decode(r.scope_id_b);
+  return r;
+}
+var RankingCore = class {
+  constructor(init2, db) {
+    this.init = init2;
+    this.db = db;
+  }
+  hot = new HotSet();
+  stmts = /* @__PURE__ */ new Map();
+  /** Prepared once per distinct statement text (the keyword statement varies only with the MAC and scope counts). */
+  stmt(sql) {
+    let st = this.stmts.get(sql);
+    if (!st) {
+      if (this.stmts.size >= 64) this.stmts.clear();
+      st = this.db.prepare(sql);
+      this.stmts.set(sql, st);
+    }
+    return st;
+  }
+  hotCount() {
+    return this.hot.size;
+  }
+  hotCapacity() {
+    return this.hot.capacity;
+  }
+  /** The meaning list a query would fuse (section 8.5 scores, the init's eval overrides applied when set). */
+  meaningScores(vec, scopes, ownerScope, nowMs) {
+    return this.hot.topK(vec, new Set(scopes), {
+      k: LIST_MAX,
+      nowMs,
+      ownerScope,
+      threshold: this.init.threshold,
+      ...this.init.priorOverride !== void 0 ? { prior: this.init.priorOverride } : {},
+      ...this.init.recencySlopeOverride !== void 0 ? { recencySlope: this.init.recencySlopeOverride } : {}
+    });
+  }
+  hotBytes() {
+    return this.hot.bytes();
+  }
+  open(sealed, aad) {
+    try {
+      return openPayload({ ciphertext: sealed, key: this.init.storeKey, associatedData: aad, suite: "xchacha20poly1305" });
+    } catch {
+      return null;
+    }
+  }
+  fields(r) {
+    return {
+      scopeKind: r.scope_kind,
+      scopeId: r.scope_id,
+      channelId: r.channel_id,
+      kind: r.kind,
+      originId: r.origin_id,
+      chunkIndex: Number(r.chunk_index),
+      parentOriginId: r.parent_id === null ? "" : String(r.parent_origin_id ?? ""),
+      parentId: r.parent_id === null ? null : Number(r.parent_id),
+      originAt: Number(r.origin_at),
+      storedAt: Number(r.stored_at)
+    };
+  }
+  row(itemId) {
+    return fixScope(this.stmt(`SELECT i.*, ${SCOPE_B}, p.origin_id AS parent_origin_id FROM agent_memory_item i LEFT JOIN agent_memory_item p
+      ON p.identity_id=i.identity_id AND p.item_id=i.parent_id WHERE i.identity_id=? AND i.item_id=?`).get(this.init.identityId, itemId));
+  }
+  addRow(r) {
+    if (r.sealed_vec === null || r.model_id !== this.init.modelId) return;
+    const plain = this.open(r.sealed_vec, itemVecAad(this.init.identityId, this.fields(r), r.model_id));
+    const vec = plain ? decodeVec(plain) : null;
+    if (vec && vec.length === DIMS) this.hot.add({ itemId: Number(r.item_id), vec, scopeId: r.scope_id, originAt: Number(r.origin_at), pinned: r.kind === "pinned" });
+  }
+  /** section 8.5 warm: one row per read, a yield between rows; returns the hot count. A disabled warm (win32 keyword-only) loads nothing. */
+  async warm() {
+    if (!this.init.warm) return 0;
+    const count = this.stmt("SELECT COUNT(*) AS n FROM agent_memory_item WHERE identity_id=? AND sealed_vec IS NOT NULL AND model_id=?").get(this.init.identityId, this.init.modelId);
+    this.hot.reserve(hotSetReserve(Number(count?.n ?? 0)));
+    let after = 0;
+    const next = this.stmt(`SELECT i.*, ${SCOPE_B}, NULL AS parent_origin_id FROM agent_memory_item i WHERE i.identity_id=? AND i.item_id>? AND i.sealed_vec IS NOT NULL
+      AND i.model_id=? ORDER BY i.item_id LIMIT 1`);
+    for (; ; ) {
+      const r = fixScope(next.get(this.init.identityId, after, this.init.modelId));
+      if (!r) return this.hot.size;
+      after = Number(r.item_id);
+      const full = r.parent_id === null ? r : this.row(after);
+      if (full) this.addRow(full);
+      await new Promise((res) => setImmediate(res));
+    }
+  }
+  /** Opens a record; null on any failure or a source_ref mismatch (section 11.3). */
+  openRecord(r) {
+    const plain = this.open(r.sealed_record, itemRecordAad(this.init.identityId, this.fields(r)));
+    const rec = plain ? decodeItemRecord(plain) : null;
+    if (!rec || (r.source_ref ?? void 0) !== rec.sourceRef) return null;
+    return rec;
+  }
+  opened(r, rec) {
+    return {
+      itemId: Number(r.item_id),
+      scopeKind: r.scope_kind,
+      scopeId: r.scope_id,
+      channelId: r.channel_id,
+      kind: r.kind,
+      originId: r.parent_id === null ? r.origin_id : String(r.parent_origin_id),
+      originAt: Number(r.origin_at),
+      source: rec.source,
+      trust: rec.trust,
+      text: rec.text
+    };
+  }
+  /** H-7: one batched statement, LIMIT 5,001 per MAC inside the allowed scopes; a MAC that fills its limit is skipped. */
+  keyword(macs, scopes) {
+    if (macs.length === 0 || scopes.length === 0) return [];
+    const ph = scopes.map(() => "?").join(",");
+    const part = `SELECT * FROM (SELECT ? AS m, t.item_id AS item_id, i.origin_at AS origin_at FROM agent_memory_token t JOIN agent_memory_item i
+      ON i.identity_id=t.identity_id AND i.item_id=t.item_id WHERE t.identity_id=? AND t.token_mac=? AND i.scope_id IN (${ph}) LIMIT ${HOT_TOKEN_MAX_POSTINGS + 1})`;
+    const sql = macs.map(() => part).join(" UNION ALL ");
+    const args = [];
+    macs.forEach((m, i) => args.push(i, this.init.identityId, m, ...scopes));
+    const rows = this.stmt(sql).all(...args);
+    const per = /* @__PURE__ */ new Map();
+    for (const r of rows) per.set(r.m, (per.get(r.m) ?? 0) + 1);
+    const hits = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if ((per.get(r.m) ?? 0) > HOT_TOKEN_MAX_POSTINGS) continue;
+      const h = hits.get(r.item_id) ?? { hits: 0, originAt: Number(r.origin_at) };
+      h.hits++;
+      hits.set(r.item_id, h);
+    }
+    return [...hits].map(([itemId, h]) => ({ itemId, ...h })).sort((a, b) => b.hits - a.hits || b.originAt - a.originAt).slice(0, LIST_MAX);
+  }
+  /** section 8.1 step 5: message ids of the newest 50 history turns of the conversation, plus the current message. */
+  excluded(q) {
+    const rows = this.stmt("SELECT message_id FROM agent_memory WHERE identity_id=? AND conversation_id=? AND message_id IS NOT NULL ORDER BY seq DESC LIMIT 50").all(this.init.identityId, q.historyConversation);
+    return /* @__PURE__ */ new Set([...rows.map((r) => r.message_id), q.currentMessageId, ...q.excludeOriginIds]);
+  }
+  rank(q) {
+    const allowed = new Set(q.scopes);
+    const meaning = q.vec ? this.meaningScores(q.vec, q.scopes, q.ownerScope, q.nowMs) : [];
+    const kw = this.keyword(q.macs, q.scopes);
+    const fused = /* @__PURE__ */ new Map();
+    meaning.forEach((m, rank) => fused.set(m.itemId, 1 / (RRF_K + rank + 1)));
+    const keywordOnlyRead = q.vec === null || !this.init.warm;
+    const kwOnly = /* @__PURE__ */ new Set();
+    kw.forEach((k, rank) => {
+      if (!fused.has(k.itemId)) kwOnly.add(k.itemId);
+      fused.set(k.itemId, (fused.get(k.itemId) ?? 0) + 1 / (RRF_K + rank + 1));
+    });
+    const ex = this.excluded(q);
+    const order = [...fused.keys()];
+    const items = [];
+    let chars = 0, openFailed = 0;
+    const candidates = [];
+    for (const id of order) {
+      const r = this.row(id);
+      if (!r || !allowed.has(r.scope_id)) continue;
+      const pendingEmbed = r.sealed_vec === null || r.model_id !== this.init.modelId;
+      if (kwOnly.has(id) && !keywordOnlyRead && !pendingEmbed) continue;
+      const fresh = 1 - Math.min(365, Math.max(0, (q.nowMs - Number(r.origin_at)) / DAY_MS)) / 365;
+      candidates.push({ r, score: fused.get(id), fresh });
+    }
+    candidates.sort((a, b) => Math.abs(b.score - a.score) > FRESHNESS_TIE_EPSILON ? b.score - a.score : b.fresh - a.fresh);
+    for (const { r } of candidates) {
+      if (items.length >= q.maxItems) break;
+      const origin = r.parent_id === null ? r.origin_id : String(r.parent_origin_id);
+      if (ex.has(origin)) continue;
+      const rec = this.openRecord(r);
+      if (rec === null) {
+        openFailed++;
+        continue;
+      }
+      if (rec.chunks !== void 0) continue;
+      if (chars + rec.text.length > q.maxChars) break;
+      chars += rec.text.length;
+      items.push(this.opened(r, rec));
+    }
+    return { items, openFailed };
+  }
+  pins(scopeId, maxChars) {
+    const rows = this.stmt(`SELECT i.*, ${SCOPE_B}, p.origin_id AS parent_origin_id FROM agent_memory_item i LEFT JOIN agent_memory_item p
+      ON p.identity_id=i.identity_id AND p.item_id=i.parent_id WHERE i.identity_id=? AND i.scope_id=? AND i.kind='pinned'
+      ORDER BY i.origin_at DESC, COALESCE(i.parent_id, i.item_id) DESC, i.chunk_index ASC`).all(this.init.identityId, scopeId);
+    rows.forEach(fixScope);
+    const pins = [];
+    let chars = 0, openFailed = 0, more = 0;
+    for (const r of rows) {
+      const rec = this.openRecord(r);
+      if (rec === null) {
+        openFailed++;
+        continue;
+      }
+      if (rec.chunks !== void 0) continue;
+      if (more > 0 || chars + rec.text.length > maxChars) {
+        more++;
+        continue;
+      }
+      chars += rec.text.length;
+      pins.push(this.opened(r, rec));
+    }
+    return { pins, more, openFailed };
+  }
+  pending(limit) {
+    const rows = this.stmt(`SELECT i.*, ${SCOPE_B}, p.origin_id AS parent_origin_id FROM agent_memory_item i LEFT JOIN agent_memory_item p
+      ON p.identity_id=i.identity_id AND p.item_id=i.parent_id WHERE i.identity_id=? AND (i.model_id IS NULL OR i.model_id<>?)
+      AND NOT EXISTS (SELECT 1 FROM agent_memory_item c WHERE c.identity_id=i.identity_id AND c.parent_id=i.item_id)
+      ORDER BY i.stored_at, i.item_id LIMIT ?`).all(this.init.identityId, this.init.modelId, limit);
+    rows.forEach(fixScope);
+    const out = [];
+    for (const r of rows) {
+      const rec = this.openRecord(r);
+      if (rec === null) continue;
+      out.push({ itemId: Number(r.item_id), channelId: r.channel_id, scopeKind: r.scope_kind, scopeId: r.scope_id, originId: r.origin_id, chunkIndex: Number(r.chunk_index), text: rec.text });
+    }
+    return out;
+  }
+  /**
+   * Final review bridge M-4: `handle` with a per-message catch. A request that throws (a prepare failure, a decode throw)
+   * is answered `failed` instead of becoming an unhandled rejection that kills the worker; a notification that throws is
+   * dropped (a later request still warms from the database). Content-free: the error is never sent or logged.
+   */
+  async handleSafe(m) {
+    try {
+      return await this.handle(m);
+    } catch {
+      return "id" in m ? { type: "failed", id: m.id } : null;
+    }
+  }
+  async handle(m) {
+    switch (m.type) {
+      case "query": {
+        const r = this.rank(m.q);
+        return { type: "result", id: m.id, items: r.items, openFailed: r.openFailed };
+      }
+      case "pins": {
+        const r = this.pins(m.scopeId, m.maxChars);
+        return { type: "pins", id: m.id, ...r };
+      }
+      case "pending":
+        return { type: "pending", id: m.id, rows: this.pending(m.limit) };
+      case "added":
+        for (const id of m.itemIds) {
+          const r = this.row(id);
+          if (r) this.addRow(r);
+        }
+        return { type: "stats", hot: this.hot.size, hotBytes: this.hot.bytes() };
+      case "removed":
+        for (const id of m.itemIds) this.hot.remove(id);
+        return { type: "stats", hot: this.hot.size, hotBytes: this.hot.bytes() };
+      case "reset":
+        this.hot.clear();
+        await this.warm();
+        return { type: "stats", hot: this.hot.size, hotBytes: this.hot.bytes() };
+    }
+  }
+};
+
+// src/memory/unified/ranking-worker.ts
+var init = workerData;
+var core = new RankingCore(init, new DatabaseSync(init.dbPath, { readOnly: true }));
+var hot = await core.warm();
+parentPort.postMessage({ type: "ready", hot, hotBytes: core.hotBytes() });
+parentPort.on("message", (m) => {
+  void core.handleSafe(m).then((r) => {
+    if (r) parentPort.postMessage(r);
+  });
+});

package/dist/version.d.ts

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