@securecoms/agent-bridge 0.28.1 → 0.29.0

package/dist/index.js

@@ -1976,7 +1976,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     k = h(byte1, seed);
     v = h();
   };
-  const gen = () => {
+  const gen2 = () => {
     if (i++ >= _maxDrbgIters)
       throw new Error("drbg: tried max amount of iterations");
     let len = 0;
@@ -1993,7 +1993,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     reset();
     reseed(seed);
     let res = void 0;
-    while ((res = pred(gen())) === void 0)
+    while ((res = pred(gen2())) === void 0)
       reseed();
     reset();
     return res;
@@ -8322,12 +8322,12 @@ function u32ToBytes(n) {
   return b;
 }
 function buildExporterContext(enclaveId, channelId, epoch) {
-  const enc4 = new TextEncoder();
-  return concatBytes(enc4.encode(enclaveId), enc4.encode(channelId), epochToBytes(epoch));
+  const enc5 = new TextEncoder();
+  return concatBytes(enc5.encode(enclaveId), enc5.encode(channelId), epochToBytes(epoch));
 }
 function buildVoiceExporterContext(enclaveId, channelId, epoch, callId) {
-  const enc4 = new TextEncoder();
-  const callIdBytes = enc4.encode(callId);
+  const enc5 = new TextEncoder();
+  const callIdBytes = enc5.encode(callId);
   return concatBytes(buildExporterContext(enclaveId, channelId, epoch), u32ToBytes(callIdBytes.length), callIdBytes);
 }
 function cipherFor(suite, key, nonce2, aad) {
@@ -8597,14 +8597,14 @@ function unpackDekMaterial(buf) {
 import { blake2b as blake2b2 } from "@noble/hashes/blake2b";
 var DEK_COMMIT_LABEL = "securecoms/vault_ref/dek/v1";
 function computeDekCommit(enclaveId, nodeId, fileKey, fileNonce) {
-  const enc4 = new TextEncoder();
+  const enc5 = new TextEncoder();
   const sep = new Uint8Array([0]);
   const parts = [
-    enc4.encode(DEK_COMMIT_LABEL),
+    enc5.encode(DEK_COMMIT_LABEL),
     sep,
-    enc4.encode(enclaveId),
+    enc5.encode(enclaveId),
     sep,
-    enc4.encode(nodeId),
+    enc5.encode(nodeId),
     sep,
     packDekMaterial(fileKey, fileNonce)
   ];
@@ -9093,16 +9093,16 @@ async function verifyApprovalArtifact(artifact, expectedPublicKeyHex) {
     return false;
   }
 }
-function encode(enc4) {
+function encode(enc5) {
   return (t) => {
-    const [len, write] = enc4(t);
+    const [len, write] = enc5(t);
     const buf = new ArrayBuffer(len);
     write(0, buf);
     return new Uint8Array(buf);
   };
 }
-function contramapBufferEncoder(enc4, f) {
-  return (u) => enc4(f(u));
+function contramapBufferEncoder(enc5, f) {
+  return (u) => enc5(f(u));
 }
 function contramapBufferEncoders(encoders, toTuple) {
   return (value) => {
@@ -9498,13 +9498,13 @@ var decodeVarLenData = (buf, offset) => {
   const data = buf.subarray(offset + lengthFieldSize, offset + totalBytes);
   return [data, totalBytes];
 };
-function varLenTypeEncoder(enc4) {
+function varLenTypeEncoder(enc5) {
   return (data) => {
     let totalLength = 0;
     let writeTotal = (_offset, _buffer) => {
     };
     for (let i = 0; i < data.length; i++) {
-      const [len, write] = enc4(data[i]);
+      const [len, write] = enc5(data[i]);
       const oldFunc = writeTotal;
       const currentLen = totalLength;
       writeTotal = (offset, buffer) => {
@@ -9652,8 +9652,8 @@ function refhash(label, value, h) {
 }
 function encodeRefHash(label, value) {
   const labelBytes = new TextEncoder().encode(label);
-  const enc4 = composeBufferEncoders([varLenDataEncoder, varLenDataEncoder]);
-  return encode(enc4)([labelBytes, value]);
+  const enc5 = composeBufferEncoders([varLenDataEncoder, varLenDataEncoder]);
+  return encode(enc5)([labelBytes, value]);
 }
 function optionalEncoder(encodeT) {
   return (t) => {
@@ -10929,8 +10929,8 @@ function encryptSecretsForPath(originalTree, updatedTree, updatedGroupContext, c
     const res = {
       hpkePublicKey: key,
       encryptedPathSecret: await Promise.all(pathSecret.sendTo.map(async (nodeIndex) => {
-        const { ct, enc: enc4 } = await encryptWithLabel(await cs.hpke.importPublicKey(getHpkePublicKey(originalTree[nodeIndex])), "UpdatePathNode", encode(groupContextEncoder)(updatedGroupContext), pathSecret.secret, cs.hpke);
-        return { ciphertext: ct, kemOutput: enc4 };
+        const { ct, enc: enc5 } = await encryptWithLabel(await cs.hpke.importPublicKey(getHpkePublicKey(originalTree[nodeIndex])), "UpdatePathNode", encode(groupContextEncoder)(updatedGroupContext), pathSecret.secret, cs.hpke);
+        return { ciphertext: ct, kemOutput: enc5 };
       }))
     };
     return res;
@@ -11552,11 +11552,11 @@ function allSecretTreeValues(tree) {
   for (const node of tree) {
     arr.push(node.application.secret);
     arr.push(node.handshake.secret);
-    for (const gen of Object.values(node.application.unusedGenerations)) {
-      arr.push(gen);
+    for (const gen2 of Object.values(node.application.unusedGenerations)) {
+      arr.push(gen2);
     }
-    for (const gen of Object.values(node.handshake.unusedGenerations)) {
-      arr.push(gen);
+    for (const gen2 of Object.values(node.handshake.unusedGenerations)) {
+      arr.push(gen2);
     }
   }
   return arr;
@@ -11624,12 +11624,12 @@ function removeOldGenerations(unusedGenerations, max) {
   const cutoff = generations.length - max;
   const consumed = new Array();
   const record = {};
-  for (const [n, gen] of generations.entries()) {
-    const value = unusedGenerations[gen];
+  for (const [n, gen2] of generations.entries()) {
+    const value = unusedGenerations[gen2];
     if (n < cutoff) {
       consumed.push(value);
     } else {
-      record[gen] = value;
+      record[gen2] = value;
     }
   }
   return [record, consumed];
@@ -14799,16 +14799,16 @@ function failDecoder2() {
 }
 
 // ../../node_modules/ts-mls/dist/src/codec/tlsEncoder.js
-function encode2(enc4) {
+function encode2(enc5) {
   return (t) => {
-    const [len, write] = enc4(t);
+    const [len, write] = enc5(t);
     const buf = new ArrayBuffer(len);
     write(0, buf);
     return new Uint8Array(buf);
   };
 }
-function contramapBufferEncoder2(enc4, f) {
-  return (u) => enc4(f(u));
+function contramapBufferEncoder2(enc5, f) {
+  return (u) => enc5(f(u));
 }
 function contramapBufferEncoders2(encoders, toTuple) {
   return (value) => {
@@ -15044,13 +15044,13 @@ var decodeVarLenData2 = (buf, offset) => {
   const data = buf.subarray(offset + lengthFieldSize, offset + totalBytes);
   return [data, totalBytes];
 };
-function varLenTypeEncoder2(enc4) {
+function varLenTypeEncoder2(enc5) {
   return (data) => {
     let totalLength = 0;
     let writeTotal = (_offset, _buffer) => {
     };
     for (let i = 0; i < data.length; i++) {
-      const [len, write] = enc4(data[i]);
+      const [len, write] = enc5(data[i]);
       const oldFunc = writeTotal;
       const currentLen = totalLength;
       writeTotal = (offset, buffer) => {
@@ -15128,8 +15128,8 @@ function refhash2(label, value, h) {
 }
 function encodeRefHash2(label, value) {
   const labelBytes = new TextEncoder().encode(label);
-  const enc4 = composeBufferEncoders2([varLenDataEncoder2, varLenDataEncoder2]);
-  return encode2(enc4)([labelBytes, value]);
+  const enc5 = composeBufferEncoders2([varLenDataEncoder2, varLenDataEncoder2]);
+  return encode2(enc5)([labelBytes, value]);
 }
 
 // ../../node_modules/ts-mls/dist/src/codec/optional.js
@@ -16599,11 +16599,11 @@ function allSecretTreeValues2(tree) {
   for (const node of tree) {
     arr.push(node.application.secret);
     arr.push(node.handshake.secret);
-    for (const gen of Object.values(node.application.unusedGenerations)) {
-      arr.push(gen);
+    for (const gen2 of Object.values(node.application.unusedGenerations)) {
+      arr.push(gen2);
     }
-    for (const gen of Object.values(node.handshake.unusedGenerations)) {
-      arr.push(gen);
+    for (const gen2 of Object.values(node.handshake.unusedGenerations)) {
+      arr.push(gen2);
     }
   }
   return arr;
@@ -16671,12 +16671,12 @@ function removeOldGenerations2(unusedGenerations, max) {
   const cutoff = generations.length - max;
   const consumed = new Array();
   const record = {};
-  for (const [n, gen] of generations.entries()) {
-    const value = unusedGenerations[gen];
+  for (const [n, gen2] of generations.entries()) {
+    const value = unusedGenerations[gen2];
     if (n < cutoff) {
       consumed.push(value);
     } else {
-      record[gen] = value;
+      record[gen2] = value;
     }
   }
   return [record, consumed];
@@ -24229,7 +24229,7 @@ function openDeliveryPings(o) {
   async function connect2() {
     if (closed)
       return;
-    const gen = connectGen;
+    const gen2 = connectGen;
     terminalReason = void 0;
     let token;
     try {
@@ -24238,7 +24238,7 @@ function openDeliveryPings(o) {
       scheduleReconnect();
       return;
     }
-    if (closed || gen !== connectGen)
+    if (closed || gen2 !== connectGen)
       return;
     const ws = new o.wsImpl(o.url, [BEARER_SUBPROTOCOL, base64UrlNoPad(token)]);
     sock = ws;
@@ -25668,7 +25668,7 @@ import { createHash } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 
 // ../connect-mls-store/dist/schema.js
-var SCHEMA_VERSION = 11;
+var SCHEMA_VERSION = 12;
 var BUSY_TIMEOUT_MS = 5e3;
 function openSchema(db) {
   db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
@@ -25881,7 +25881,67 @@ function openSchema(db) {
       );
     `);
   }
+  if (row.user_version < 12) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_memory_item (
+        identity_id   TEXT NOT NULL,
+        item_id       INTEGER NOT NULL,
+        scope_kind    TEXT NOT NULL,
+        scope_id      TEXT NOT NULL,
+        channel_id    TEXT NOT NULL,
+        kind          TEXT NOT NULL,
+        origin_id     TEXT NOT NULL,
+        chunk_index   INTEGER NOT NULL,
+        parent_id     INTEGER,
+        source_ref    TEXT,
+        sealed_record BLOB NOT NULL,
+        sealed_vec    BLOB,
+        model_id      TEXT,
+        origin_at     INTEGER NOT NULL,
+        stored_at     INTEGER NOT NULL,
+        sealed_bytes  INTEGER NOT NULL,
+        PRIMARY KEY (identity_id, item_id),
+        UNIQUE (identity_id, scope_kind, scope_id, origin_id, chunk_index)
+      );
+    `);
+    db.exec("CREATE INDEX IF NOT EXISTS agent_memory_item_age ON agent_memory_item (identity_id, kind, origin_at, item_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS agent_memory_item_scope ON agent_memory_item (identity_id, scope_id, kind, origin_at);");
+    db.exec("CREATE INDEX IF NOT EXISTS agent_memory_item_channel ON agent_memory_item (identity_id, channel_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS agent_memory_item_parent ON agent_memory_item (identity_id, parent_id);");
+    db.exec("CREATE INDEX IF NOT EXISTS agent_memory_item_source ON agent_memory_item (identity_id, source_ref) WHERE source_ref IS NOT NULL;");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_memory_token (
+        identity_id TEXT NOT NULL,
+        token_mac   BLOB NOT NULL,
+        item_id     INTEGER NOT NULL,
+        PRIMARY KEY (identity_id, token_mac, item_id)
+      );
+    `);
+    db.exec("CREATE INDEX IF NOT EXISTS agent_memory_token_item ON agent_memory_token (identity_id, item_id);");
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_memory_quota (
+        identity_id TEXT NOT NULL,
+        channel_id  TEXT NOT NULL,
+        sender_id   TEXT NOT NULL DEFAULT '',
+        day         TEXT NOT NULL,
+        count       INTEGER NOT NULL,
+        PRIMARY KEY (identity_id, channel_id, sender_id, day)
+      );
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_memory_migration (
+        identity_id     TEXT NOT NULL,
+        source          TEXT NOT NULL,
+        conversation_id TEXT NOT NULL,
+        marker          INTEGER NOT NULL,
+        PRIMARY KEY (identity_id, source, conversation_id)
+      );
+    `);
+  }
   ensureRecallStateColumns(db);
+  ensureUnifiedStateColumns(db);
+  ensureUnifiedEvictIndex(db);
+  ensureUnifiedDmOwner(db);
   ensureConversationLastAbsentAt(db);
   ensureRecallForgetTables(db);
   ensureRuntimeInboxDeliveryAttempts(db);
@@ -26017,6 +26077,47 @@ function ensureConversationLastAbsentAt(db) {
     throw e;
   }
 }
+var UNIFIED_STATE_COLUMNS = [
+  ["unified_enabled", "INTEGER NOT NULL DEFAULT 0"],
+  ["enable_epoch", "INTEGER NOT NULL DEFAULT 0"],
+  ["unified_applied_clear_generation", "INTEGER NOT NULL DEFAULT 0"],
+  ["item_high_water", "INTEGER NOT NULL DEFAULT 0"],
+  ["size_bytes", "INTEGER NOT NULL DEFAULT 0"],
+  ["item_count", "INTEGER NOT NULL DEFAULT 0"],
+  ["room_clears_applied", "TEXT NOT NULL DEFAULT '{}'"],
+  // Final review store I-1: the owner-DM share of size_bytes / item_count, so at-cap eviction never scans the item table
+  // for the R-U10 floor. -1 = not yet counted (a file from before this column, or a fresh state row): the store counts
+  // once, inside its next eviction transaction, and maintains the value incrementally after that.
+  ["owner_size_bytes", "INTEGER NOT NULL DEFAULT -1"],
+  ["owner_item_count", "INTEGER NOT NULL DEFAULT -1"]
+];
+function ensureUnifiedEvictIndex(db) {
+  db.exec("CREATE INDEX IF NOT EXISTS agent_memory_item_kind_age ON agent_memory_item (identity_id, kind, scope_kind, origin_at, item_id);");
+}
+function ensureUnifiedDmOwner(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_memory_dm_owner (
+      identity_id       TEXT NOT NULL,
+      channel_id        TEXT NOT NULL,
+      owner_identity_id TEXT NOT NULL,
+      PRIMARY KEY (identity_id, channel_id)
+    );
+  `);
+}
+function ensureUnifiedStateColumns(db) {
+  const has = (name) => db.prepare("PRAGMA table_info(agent_memory_state)").all().some((c) => c.name === name);
+  for (const [name, decl] of UNIFIED_STATE_COLUMNS) {
+    if (has(name))
+      continue;
+    try {
+      db.exec(`ALTER TABLE agent_memory_state ADD COLUMN ${name} ${decl}`);
+    } catch (e) {
+      if (has(name))
+        continue;
+      throw e;
+    }
+  }
+}
 
 // ../connect-mls-store/dist/errors.js
 var MlsStoreCorruptError = class extends Error {
@@ -26078,6 +26179,127 @@ function decodeVec(b) {
 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 COVERAGE_SOURCES = /* @__PURE__ */ new Set(["owner_typed", "migrated_recall", "owner_pin", "migrated_note"]);
+var ITEM_CAP_DEFAULT = 1e5;
+var BYTE_CAP_DEFAULT = 2 * 1024 * 1024 * 1024;
+var PIN_CAP = 200;
+var PIN_MAX_CHARS = 400;
+var EVICT_BATCH_MAX = 500;
+var OWNER_DM_FLOOR_SHARE = 0.25;
+var SCOPE_SHARE_MAX = 0.25;
+var ITEM_ROW_OVERHEAD_BYTES = Math.max(48, 2388);
+var TOKEN_ROW_OVERHEAD_BYTES = Math.max(48, 180);
+var NUL = "\0";
+var enc4 = new TextEncoder();
+var noNul = (v, what) => {
+  if (v.includes(NUL))
+    throw new RangeError(`${what} holds a NUL`);
+};
+function ownerDmScopeId(channelId, ownerIdentityId) {
+  noNul(channelId, "channel id");
+  noNul(ownerIdentityId, "owner identity id");
+  if (!channelId || !ownerIdentityId)
+    throw new RangeError("empty scope id part");
+  return `${channelId}${NUL}${ownerIdentityId}`;
+}
+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(kind2, scopeId) {
+  if (kind2 === "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 enc4.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 enc4.encode(["agent_memory_item_vec", identityId, f.scopeKind, f.scopeId, f.originId, String(f.chunkIndex), modelId].join(NUL));
+}
+function encodeItemRecord(r) {
+  return enc4.encode(JSON.stringify({ v: 1, t: r.text, s: r.source, tr: r.trust, ...r.sourceRef !== void 0 ? { sr: r.sourceRef } : {}, ...r.chunks !== void 0 ? { c: r.chunks } : {} }));
+}
+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 } : {} };
+}
+var noteSourceRef = (conversationId, noteId) => `agent_memory_note:${conversationId}:${noteId}`;
+var recallSourceRef = (conversationId, messageId) => `agent_memory_recall:${conversationId}:${messageId}`;
+var historySourceRef = (conversationId, seq) => `agent_memory:${conversationId}:${seq}`;
+
 // ../connect-mls-store/dist/sqlite-store.js
 function encodeBundle(bundle) {
   const pp = bundle.privatePackage;
@@ -26116,6 +26338,7 @@ function bytesEqual(a, b) {
 function sameTag(prior, tag) {
   return prior !== null && prior.groupId === tag.groupId && prior.epoch === tag.epoch;
 }
+var UTF8 = new TextDecoder();
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_MEMORY_RETENTION_MS = 30 * DAY_MS;
 var DEFAULT_MEMORY_FACT_RETENTION_K = 200;
@@ -26144,7 +26367,26 @@ var FactNotConsumed = class extends Error {
 };
 var BudgetSpent = class extends Error {
 };
-var SqliteMlsStateStore = class {
+var MIGRATION_READ_SLICE = 20;
+var yieldToLoop = () => new Promise((r) => setImmediate(r));
+var STATEMENT_CACHE_MAX = 512;
+function cachePreparedStatements(db) {
+  const prepare = db.prepare.bind(db);
+  const cache = /* @__PURE__ */ new Map();
+  db.prepare = (sql, options) => {
+    if (options !== void 0)
+      return prepare(sql, options);
+    let st = cache.get(sql);
+    if (st === void 0) {
+      if (cache.size >= STATEMENT_CACHE_MAX)
+        cache.clear();
+      st = prepare(sql);
+      cache.set(sql, st);
+    }
+    return st;
+  };
+}
+var SqliteMlsStateStore = class _SqliteMlsStateStore {
   db;
   id;
   cipher;
@@ -26162,6 +26404,8 @@ var SqliteMlsStateStore = class {
   memoryFactRetentionMs;
   memoryNow;
   recallMaxRows;
+  itemCap;
+  byteCap;
   // M0(b)/F4-1 + C1 + H2: in-memory ONLY for now — the daemon side of FileSafe
   // (this store) isn't wired into the multi-member vault yet (Task 5's capture
   // sites are all connect-web/browser owner paths). Kept here purely so
@@ -26183,6 +26427,8 @@ var SqliteMlsStateStore = class {
     this.memoryFactRetentionMs = opts.memoryFactRetentionMs ?? DEFAULT_MEMORY_FACT_RETENTION_MS;
     this.memoryNow = opts.memoryNow ?? Date.now;
     this.recallMaxRows = opts.recallMaxRows ?? RECALL_MAX_ROWS;
+    this.itemCap = opts.itemCap ?? ITEM_CAP_DEFAULT;
+    this.byteCap = opts.byteCap ?? BYTE_CAP_DEFAULT;
     try {
       this.db = new DatabaseSync(opts.dbPath);
     } catch (e) {
@@ -26207,6 +26453,7 @@ var SqliteMlsStateStore = class {
         throw new MlsStoreCorruptError(r.integrity_check);
       }
     }
+    cachePreparedStatements(this.db);
   }
   async seal(state) {
     return this.cipher.seal(new TextEncoder().encode(JSON.stringify(state)));
@@ -26894,6 +27141,10 @@ var SqliteMlsStateStore = class {
       this.db.prepare("DELETE FROM agent_memory_fact_assignment WHERE identity_id=? AND conversation_id=?").run(this.id, conversationId);
       this.db.prepare("DELETE FROM agent_memory_note WHERE identity_id=? AND conversation_id=?").run(this.id, conversationId);
       this.db.prepare("DELETE FROM agent_memory_recall WHERE identity_id=? AND conversation_id=?").run(this.id, conversationId);
+      this.db.prepare("DELETE FROM agent_memory_token WHERE identity_id=? AND item_id IN (SELECT item_id FROM agent_memory_item WHERE identity_id=? AND channel_id=?)").run(this.id, this.id, conversationId);
+      this.db.prepare("DELETE FROM agent_memory_item WHERE identity_id=? AND channel_id=?").run(this.id, conversationId);
+      this.db.prepare("DELETE FROM agent_memory_dm_owner WHERE identity_id=? AND channel_id=?").run(this.id, conversationId);
+      this.recountItemAccounts();
       this.db.prepare(`INSERT INTO agent_memory_conversation (identity_id, conversation_id, purge_epoch, content_epoch) VALUES (?, ?, 1, 1)
          ON CONFLICT(identity_id, conversation_id) DO UPDATE SET purge_epoch = purge_epoch + 1,
            content_epoch = content_epoch + 1, first_absent_at = NULL, absent_refreshes = 0, last_absent_at = NULL`).run(this.id, conversationId);
@@ -27176,6 +27427,540 @@ var SqliteMlsStateStore = class {
       return Number(info.changes) === 1;
     });
   }
+  // ── Unified memory (schema v12, spec 2026-10-10 §11) ─────────────────
+  // THE AWAIT TRAP (as for notes and recall): seal and open are awaited BEFORE or OUTSIDE any transaction;
+  // reserveItemIds, insertItems and every delete are synchronous by type and re-check the capture inside
+  // BEGIN IMMEDIATE (U11). The turn read path does not run here: it runs in the bridge's ranking worker (§8.5).
+  /** §11.3. A failure is MlsStoreSealError and nothing is written (U2). */
+  async sealItemRecord(f, r) {
+    try {
+      return await this.cipher.sealWithAad(encodeItemRecord(r), itemRecordAad(this.id, f));
+    } catch (e) {
+      throw new MlsStoreSealError(String(e?.message ?? e));
+    }
+  }
+  async sealItemVec(f, modelId, vec) {
+    try {
+      if (vec.length === 0 || vec.length > RECALL_MAX_DIMS || vec.some((x) => !Number.isFinite(x)))
+        throw new Error("invalid vector");
+      return await this.cipher.sealWithAad(encodeVec(vec), itemVecAad(this.id, f, modelId));
+    } catch (e) {
+      throw new MlsStoreSealError(String(e?.message ?? e));
+    }
+  }
+  /** U2: an open failure, or a record that does not decode, is null (the caller omits and counts it). */
+  async openItemRecord(row) {
+    try {
+      const rec = decodeItemRecord(await this.cipher.openWithAad(row.sealedRecord, itemRecordAad(this.id, row)));
+      if (rec === null || (row.sourceRef ?? void 0) !== rec.sourceRef)
+        return null;
+      return rec;
+    } catch {
+      return null;
+    }
+  }
+  async openItemVec(row) {
+    if (row.sealedVec === null || row.modelId === null)
+      return null;
+    try {
+      return decodeVec(await this.cipher.openWithAad(row.sealedVec, itemVecAad(this.id, row, row.modelId)));
+    } catch {
+      return null;
+    }
+  }
+  unifiedState() {
+    const r = this.db.prepare(`SELECT unified_enabled AS e, enable_epoch AS p, unified_applied_clear_generation AS g, item_high_water AS h, size_bytes AS s, item_count AS n,
+              room_clears_applied AS rc FROM agent_memory_state WHERE identity_id=?`).get(this.id);
+    let roomClears = {};
+    let roomClearsBad = false;
+    try {
+      const o = JSON.parse(r?.rc ?? "{}");
+      if (o && typeof o === "object" && !Array.isArray(o))
+        roomClears = o;
+      else
+        roomClearsBad = true;
+    } catch {
+      roomClearsBad = true;
+    }
+    return { enabled: r ? Number(r.e) === 1 : false, enableEpoch: r ? Number(r.p) : 0, applied: r ? Number(r.g) : 0, highWater: r ? Number(r.h) : 0, sizeBytes: r ? Number(r.s) : 0, itemCount: r ? Number(r.n) : 0, roomClears, roomClearsBad };
+  }
+  /** §14.5 (H-5): a clear applied by a 0.28 bridge moved applied_clear_generation past the unified one. */
+  unifiedClearLagging() {
+    return this.unifiedState().applied < this.memoryClearGeneration();
+  }
+  /** U11, synchronous: the five values a writer captures before its first await. */
+  itemCapture(channelId) {
+    const st = this.unifiedState();
+    const g = st.roomClears[channelId];
+    return {
+      clearGeneration: st.applied,
+      roomClearGeneration: typeof g === "number" && Number.isSafeInteger(g) ? g : 0,
+      enableEpoch: st.enableEpoch,
+      purgeEpoch: this.conversationPurgeEpoch(channelId),
+      contentEpoch: this.conversationContentEpoch(channelId)
+    };
+  }
+  /** §13: off→on and on→off each move the epoch, so a capture taken on the other side never inserts. */
+  setUnifiedEnabled(on) {
+    return this.immediate(() => {
+      this.ensureStateRow();
+      this.db.prepare("UPDATE agent_memory_state SET enable_epoch=enable_epoch+1, unified_enabled=? WHERE identity_id=? AND unified_enabled<>?").run(on ? 1 : 0, this.id, on ? 1 : 0);
+      return this.unifiedState().enableEpoch;
+    });
+  }
+  /** Plan correction 5: ids are reserved before sealing (the chunk AAD binds parent_id). Never reused. */
+  reserveItemIds(n) {
+    if (!Number.isSafeInteger(n) || n < 1 || n > 1e4)
+      throw new RangeError("reserve count");
+    return this.immediate(() => {
+      this.ensureStateRow();
+      const first = this.unifiedState().highWater + 1;
+      this.db.prepare("UPDATE agent_memory_state SET item_high_water=? WHERE identity_id=?").run(first + n - 1, this.id);
+      return first;
+    });
+  }
+  /** The stale reason, or null. Call inside a transaction. The content epoch is NOT compared (a forget must not refuse an insert; the 7b rule). */
+  staleItemCapture(channelId, c) {
+    const st = this.unifiedState();
+    if (st.applied !== c.clearGeneration || this.unifiedClearLagging())
+      return "cleared";
+    if (st.roomClearsBad)
+      return "room_cleared";
+    const g = st.roomClears[channelId];
+    if ((typeof g === "number" && Number.isSafeInteger(g) ? g : 0) !== c.roomClearGeneration)
+      return "room_cleared";
+    if (!st.enabled || st.enableEpoch !== c.enableEpoch)
+      return "disabled";
+    if (this.conversationPurgeEpoch(channelId) !== c.purgeEpoch)
+      return "purged";
+    return null;
+  }
+  itemRowFrom(r) {
+    return {
+      itemId: Number(r.item_id),
+      scopeKind: r.scope_kind,
+      scopeId: UTF8.decode(r.scope_id_b),
+      channelId: String(r.channel_id),
+      kind: r.kind,
+      originId: String(r.origin_id),
+      chunkIndex: Number(r.chunk_index),
+      parentId: r.parent_id === null ? null : Number(r.parent_id),
+      parentOriginId: r.parent_id === null ? "" : String(r.parent_origin_id ?? ""),
+      sourceRef: r.source_ref === null ? null : String(r.source_ref),
+      sealedRecord: r.sealed_record,
+      sealedVec: r.sealed_vec ?? null,
+      modelId: r.model_id === null ? null : String(r.model_id),
+      originAt: Number(r.origin_at),
+      storedAt: Number(r.stored_at),
+      sealedBytes: Number(r.sealed_bytes)
+    };
+  }
+  /** Rows joined with their parent's origin id (a chunk's AAD needs it). scope_id is read as a BLOB: an owner-DM scope id holds NUL
+   *  (channel‖0‖owner, §11.2) and node:sqlite's TEXT read truncates at the first NUL; binding and equality are NUL-safe. */
+  static ITEM_SELECT = `SELECT i.*, CAST(i.scope_id AS BLOB) AS scope_id_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`;
+  /** Chunk 0 of one origin in one scope: the parent or the unchunked item. A primary-key-sized write-path read. */
+  itemByOrigin(scopeKind, scopeId, originId) {
+    const r = this.db.prepare(`${_SqliteMlsStateStore.ITEM_SELECT} WHERE i.identity_id=? AND i.scope_kind=? AND i.scope_id=? AND i.origin_id=? AND i.chunk_index=0`).get(this.id, scopeKind, scopeId, originId);
+    return r ? this.itemRowFrom(r) : void 0;
+  }
+  /** One row by id (forget, tests). */
+  itemById(itemId) {
+    const r = this.db.prepare(`${_SqliteMlsStateStore.ITEM_SELECT} WHERE i.identity_id=? AND i.item_id=?`).get(this.id, itemId);
+    return r ? this.itemRowFrom(r) : void 0;
+  }
+  unifiedAccounts() {
+    const st = this.unifiedState();
+    return { sizeBytes: st.sizeBytes, itemCount: st.itemCount };
+  }
+  /** `ownerDm`: the rows are owner-DM rows, so the owner share moves too (final review store I-1; -1 = not yet counted stays -1). */
+  bumpAccounts(dBytes, dItems, ownerDm) {
+    this.db.prepare("UPDATE agent_memory_state SET size_bytes=MAX(0, size_bytes+?), item_count=MAX(0, item_count+?) WHERE identity_id=?").run(dBytes, dItems, this.id);
+    if (ownerDm) {
+      this.db.prepare(`UPDATE agent_memory_state SET owner_size_bytes=CASE WHEN owner_size_bytes<0 THEN -1 ELSE MAX(0, owner_size_bytes+?) END,
+           owner_item_count=CASE WHEN owner_item_count<0 THEN -1 ELSE MAX(0, owner_item_count+?) END WHERE identity_id=?`).run(dBytes, dItems, this.id);
+    }
+  }
+  /**
+   * Final review store I-1: the owner-DM load (R-U10 floor) from the maintained share; counted once (a full read, inside the
+   * caller's transaction) when the share is not yet known, then kept incrementally by bumpAccounts and the recounts.
+   */
+  ownerLoad() {
+    const r = this.db.prepare("SELECT owner_size_bytes AS b, owner_item_count AS n FROM agent_memory_state WHERE identity_id=?").get(this.id);
+    if (r && Number(r.b) >= 0 && Number(r.n) >= 0)
+      return { items: Number(r.n), bytes: Number(r.b) };
+    const own = this.scopeLoad("i.scope_kind='owner_dm'");
+    this.ensureStateRow();
+    this.db.prepare("UPDATE agent_memory_state SET owner_size_bytes=?, owner_item_count=? WHERE identity_id=?").run(own.bytes, own.items, this.id);
+    return own;
+  }
+  /** Inside a transaction: delete one origin group (the row, or the parent and its chunks) and its token rows; returns the ids and the accounts it held. */
+  deleteItemGroup(firstItemId) {
+    const cols = "item_id, sealed_bytes, chunk_index, parent_id, channel_id, scope_kind";
+    const rows = this.db.prepare(`SELECT ${cols} FROM agent_memory_item WHERE identity_id=? AND item_id=? UNION ALL SELECT ${cols} FROM agent_memory_item WHERE identity_id=? AND parent_id=?`).all(this.id, firstItemId, this.id, firstItemId);
+    if (rows.length === 0)
+      return { ids: [], bytes: 0, items: 0, channelId: null, scopeKind: null };
+    const hasChunks = rows.some((r) => r.parent_id !== null);
+    let bytes = 0;
+    const tok = this.db.prepare("SELECT COUNT(*) AS n FROM agent_memory_token WHERE identity_id=? AND item_id=?");
+    for (const r of rows)
+      bytes += Number(r.sealed_bytes) + ITEM_ROW_OVERHEAD_BYTES + Number(tok.get(this.id, r.item_id).n) * TOKEN_ROW_OVERHEAD_BYTES;
+    const items = hasChunks ? rows.filter((r) => r.parent_id !== null).length : rows.length;
+    const delTok = this.db.prepare("DELETE FROM agent_memory_token WHERE identity_id=? AND item_id=?");
+    for (const r of rows)
+      delTok.run(this.id, r.item_id);
+    this.db.prepare("DELETE FROM agent_memory_item WHERE identity_id=? AND parent_id=?").run(this.id, firstItemId);
+    this.db.prepare("DELETE FROM agent_memory_item WHERE identity_id=? AND item_id=?").run(this.id, firstItemId);
+    const scopeKind = rows[0].scope_kind;
+    this.bumpAccounts(-bytes, -items, scopeKind === "owner_dm");
+    return { ids: rows.map((r) => Number(r.item_id)), bytes, items, channelId: rows[0].channel_id, scopeKind };
+  }
+  /** The single insert (U9: one caller, the bridge's ItemBook.commit; spec §7.7 step 7). */
+  insertItems(w) {
+    if (!this.validItemWrite(w))
+      return { ok: false, reason: "invalid" };
+    return this.immediate(() => {
+      const stale = this.staleItemCapture(w.channelId, w.expect);
+      if (stale)
+        return { ok: false, reason: stale };
+      if (w.replace) {
+        const prior = this.db.prepare("SELECT sealed_record FROM agent_memory_item WHERE identity_id=? AND item_id=? AND chunk_index=0 AND scope_kind=? AND scope_id=? AND origin_id=?").get(this.id, w.replace.firstItemId, w.scopeKind, w.scopeId, w.originId);
+        if (!prior || Buffer.compare(Buffer.from(prior.sealed_record), Buffer.from(w.replace.priorSealed)) !== 0)
+          return { ok: false, reason: "changed" };
+      } else {
+        const dup = this.db.prepare("SELECT 1 FROM agent_memory_item WHERE identity_id=? AND scope_kind=? AND scope_id=? AND origin_id=? AND chunk_index=0").get(this.id, w.scopeKind, w.scopeId, w.originId);
+        if (dup)
+          return { ok: false, reason: "duplicate" };
+      }
+      if (w.kind === "pinned" && w.capExempt !== true) {
+        const { n } = this.db.prepare("SELECT COUNT(*) AS n FROM agent_memory_item WHERE identity_id=? AND kind='pinned' AND item_id<>? AND IFNULL(parent_id,-1)<>?").get(this.id, w.replace?.firstItemId ?? 0, w.replace?.firstItemId ?? 0);
+        if (Number(n) >= PIN_CAP)
+          return { ok: false, reason: "pin_cap" };
+      }
+      if (w.quota && !this.takeQuota(w.channelId, w.quota))
+        return { ok: false, reason: "quota" };
+      if (w.replace) {
+        this.deleteItemGroup(w.replace.firstItemId);
+        this.bumpContentEpoch(w.channelId);
+      }
+      const ins = this.db.prepare(`INSERT INTO agent_memory_item (identity_id, item_id, scope_kind, scope_id, channel_id, kind, origin_id, chunk_index, parent_id, source_ref,
+           sealed_record, sealed_vec, model_id, origin_at, stored_at, sealed_bytes) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`);
+      const tok = this.db.prepare("INSERT OR IGNORE INTO agent_memory_token (identity_id, token_mac, item_id) VALUES (?, ?, ?)");
+      let bytes = 0;
+      let items = 0;
+      for (const p of w.parts) {
+        const sealedBytes = p.sealedRecord.length + (p.sealedVec?.length ?? 0);
+        ins.run(this.id, p.itemId, w.scopeKind, w.scopeId, w.channelId, w.kind, w.originId, p.chunkIndex, p.parentId, w.sourceRef, p.sealedRecord, p.sealedVec, p.modelId, w.originAt, w.storedAt, sealedBytes);
+        let tokens2 = 0;
+        for (const m of p.tokenMacs)
+          tokens2 += Number(tok.run(this.id, m, p.itemId).changes);
+        bytes += sealedBytes + ITEM_ROW_OVERHEAD_BYTES + tokens2 * TOKEN_ROW_OVERHEAD_BYTES;
+        if (p.embeddable)
+          items++;
+      }
+      this.bumpAccounts(bytes, items, w.scopeKind === "owner_dm");
+      this.db.prepare("INSERT INTO agent_memory_conversation (identity_id, conversation_id) VALUES (?, ?) ON CONFLICT DO NOTHING").run(this.id, w.channelId);
+      const ev = this.evictWithin(w.scopeKind, w.scopeId);
+      return { ok: true, itemIds: w.parts.map((p) => p.itemId), evicted: ev.evicted, overCap: ev.overCap, capture: this.itemCapture(w.channelId) };
+    });
+  }
+  /** Structural checks before any transaction: ids reserved (≤ high water), parent first, chunks point at it, safe integers. */
+  validItemWrite(w) {
+    if (w.parts.length === 0)
+      return false;
+    const hw = this.unifiedState().highWater;
+    const ints = (n) => Number.isSafeInteger(n);
+    if (!ints(w.originAt) || !ints(w.storedAt))
+      return false;
+    if (w.quota && w.quota.senderId === "")
+      return false;
+    const first = w.parts[0];
+    if (first.chunkIndex !== 0 || first.parentId !== null)
+      return false;
+    for (const [i, p] of w.parts.entries()) {
+      if (!ints(p.itemId) || p.itemId < 1 || p.itemId > hw)
+        return false;
+      if (p.sealedVec === null !== (p.modelId === null))
+        return false;
+      if (i > 0 && (p.chunkIndex !== i || p.parentId !== first.itemId || p.parentOriginId !== w.originId))
+        return false;
+    }
+    if (w.parts.length > 1 && first.embeddable)
+      return false;
+    return true;
+  }
+  /** §8 lazy embed: compare-and-set on the model id, the capture re-checked inside the transaction. Moves no epoch. */
+  updateItemVec(itemId, expectModelId, sealedVec, modelId, channelId, expect) {
+    return this.immediate(() => {
+      if (this.staleItemCapture(channelId, expect))
+        return false;
+      const info = this.db.prepare("UPDATE agent_memory_item SET sealed_vec=?, model_id=?, sealed_bytes=sealed_bytes+? WHERE identity_id=? AND item_id=? AND channel_id=? AND model_id IS ?").run(sealedVec, modelId, sealedVec.length, this.id, itemId, channelId, expectModelId);
+      if (Number(info.changes) !== 1)
+        return false;
+      const k = this.db.prepare("SELECT scope_kind AS k FROM agent_memory_item WHERE identity_id=? AND item_id=?").get(this.id, itemId);
+      this.bumpAccounts(sealedVec.length, 0, k.k === "owner_dm");
+      return true;
+    });
+  }
+  overCap() {
+    const st = this.unifiedState();
+    return { overItems: st.itemCount > this.itemCap, overBytes: st.sizeBytes > this.byteCap };
+  }
+  /**
+   * §14.3: embeddable rows and ACCOUNTED bytes (sealed bytes + per-row overhead for item rows and token rows, the same basis as
+   * size_bytes) of the rows matching `where` (the floor and the share). scope_id is only ever compared in SQL (CARRY-NUL).
+   */
+  scopeLoad(where, ...args2) {
+    const r = this.db.prepare(`SELECT COUNT(*) FILTER (WHERE NOT EXISTS (SELECT 1 FROM agent_memory_item c WHERE c.identity_id=i.identity_id AND c.parent_id=i.item_id)) AS n,
+              COALESCE(SUM(i.sealed_bytes + ${ITEM_ROW_OVERHEAD_BYTES} + ${TOKEN_ROW_OVERHEAD_BYTES} * (SELECT COUNT(*) FROM agent_memory_token t WHERE t.identity_id=i.identity_id AND t.item_id=i.item_id)), 0) AS b FROM agent_memory_item i WHERE i.identity_id=? AND ${where}`).get(this.id, ...args2);
+    return { items: Number(r.n), bytes: Number(r.b) };
+  }
+  /** The oldest auto group head (a parent or an unchunked row). Pins are never chosen. */
+  oldestAutoGroup(filter) {
+    if (filter.notOwnerDm) {
+      const q = this.db.prepare(`SELECT item_id, origin_at FROM agent_memory_item INDEXED BY agent_memory_item_kind_age WHERE identity_id=? AND kind='auto' AND scope_kind=? AND parent_id IS NULL
+         ORDER BY origin_at ASC, item_id ASC LIMIT 1`);
+      const heads = ["room", "person_dm"].map((k) => q.get(this.id, k)).filter((h) => h !== void 0).sort((a, b) => Number(a.origin_at) - Number(b.origin_at) || Number(a.item_id) - Number(b.item_id));
+      return heads.length ? Number(heads[0].item_id) : void 0;
+    }
+    const r = this.db.prepare(`SELECT item_id FROM agent_memory_item WHERE identity_id=? AND kind='auto' AND parent_id IS NULL
+         ${filter.scopeId !== void 0 ? "AND scope_kind=? AND scope_id=?" : ""}
+       ORDER BY origin_at ASC, item_id ASC LIMIT 1`).get(this.id, ...filter.scopeId !== void 0 ? [filter.scopeKind, filter.scopeId] : []);
+    return r ? Number(r.item_id) : void 0;
+  }
+  groupSize(firstItemId) {
+    return Number(this.db.prepare("SELECT (SELECT COUNT(*) FROM agent_memory_item WHERE identity_id=? AND item_id=?) + (SELECT COUNT(*) FROM agent_memory_item WHERE identity_id=? AND parent_id=?) AS n").get(this.id, firstItemId, this.id, firstItemId).n);
+  }
+  /**
+   * Inside a transaction (§7.7 step 7, H-7): first the G-2 share of the written scope (room and person-DM scopes only),
+   * then the two caps with the R-U10 owner-DM floor. A batch stops before a group that would take it past EVICT_BATCH_MAX
+   * rows (a first group larger than the batch is deleted alone); `overCap` tells the bridge to call evictBatch again
+   * after a yield. Pins are never chosen.
+   */
+  evictWithin(scopeKind, scopeId) {
+    const evicted = [];
+    const channels = /* @__PURE__ */ new Set();
+    const drop = (id) => {
+      if (evicted.length > 0 && evicted.length + this.groupSize(id) > EVICT_BATCH_MAX)
+        return null;
+      const g = this.deleteItemGroup(id);
+      evicted.push(...g.ids);
+      if (g.channelId)
+        channels.add(g.channelId);
+      return g;
+    };
+    if (scopeKind !== "owner_dm") {
+      const load = this.scopeLoad("i.scope_kind=? AND i.scope_id=?", scopeKind, scopeId);
+      for (; ; ) {
+        if (load.items <= this.itemCap * SCOPE_SHARE_MAX && load.bytes <= this.byteCap * SCOPE_SHARE_MAX)
+          break;
+        const v = this.oldestAutoGroup({ scopeKind, scopeId });
+        const g = v === void 0 ? null : drop(v);
+        if (!g)
+          break;
+        load.items -= g.items;
+        load.bytes -= g.bytes;
+      }
+    }
+    for (; ; ) {
+      const o2 = this.overCap();
+      if (!o2.overItems && !o2.overBytes)
+        break;
+      const own = this.ownerLoad();
+      const protectOwner = (!o2.overItems || own.items < this.itemCap * OWNER_DM_FLOOR_SHARE) && (!o2.overBytes || own.bytes < this.byteCap * OWNER_DM_FLOOR_SHARE);
+      const v = (protectOwner ? this.oldestAutoGroup({ notOwnerDm: true }) : void 0) ?? this.oldestAutoGroup({});
+      if (v === void 0 || !drop(v))
+        break;
+    }
+    for (const c of channels)
+      this.bumpContentEpoch(c);
+    const o = this.overCap();
+    return { evicted, overCap: o.overItems || o.overBytes };
+  }
+  /** H-7: one more batch, in its own transaction. The bridge yields between calls (Task 31). */
+  evictBatch() {
+    return this.immediate(() => this.evictWithin("owner_dm", ""));
+  }
+  /** §14.3 80% warning, the account half (the bridge adds the database file size, Task 31). */
+  itemCapState() {
+    const st = this.unifiedState();
+    return { ...this.overCap(), nearFull: st.itemCount > this.itemCap * 0.8 || st.sizeBytes > this.byteCap * 0.8 };
+  }
+  /** Inside a transaction: the accounts from scratch (a bulk delete). Parents do not count (plan I-2). */
+  recountItemAccounts() {
+    this.ensureStateRow();
+    const it = this.db.prepare(`SELECT COUNT(*) AS rows, COALESCE(SUM(sealed_bytes), 0) AS b,
+              COUNT(*) FILTER (WHERE NOT EXISTS (SELECT 1 FROM agent_memory_item c WHERE c.identity_id=i.identity_id AND c.parent_id=i.item_id)) AS n
+       FROM agent_memory_item i WHERE identity_id=?`).get(this.id);
+    const tk = this.db.prepare("SELECT COUNT(*) AS n FROM agent_memory_token WHERE identity_id=?").get(this.id);
+    const size = Number(it.b) + Number(it.rows) * ITEM_ROW_OVERHEAD_BYTES + Number(tk.n) * TOKEN_ROW_OVERHEAD_BYTES;
+    const own = this.scopeLoad("i.scope_kind='owner_dm'");
+    this.db.prepare("UPDATE agent_memory_state SET size_bytes=?, item_count=?, owner_size_bytes=?, owner_item_count=? WHERE identity_id=?").run(size, Number(it.n), own.bytes, own.items, this.id);
+  }
+  /** Inside a transaction: delete every unified row of the identity and move each channel's content epoch. */
+  deleteAllItems() {
+    const chans = this.db.prepare("SELECT DISTINCT channel_id AS c FROM agent_memory_item WHERE identity_id=?").all(this.id).map((r) => r.c);
+    this.db.prepare("DELETE FROM agent_memory_token WHERE identity_id=?").run(this.id);
+    this.db.prepare("DELETE FROM agent_memory_item WHERE identity_id=?").run(this.id);
+    this.db.prepare("DELETE FROM agent_memory_quota WHERE identity_id=?").run(this.id);
+    this.db.prepare("UPDATE agent_memory_state SET size_bytes=0, item_count=0, owner_size_bytes=0, owner_item_count=0 WHERE identity_id=?").run(this.id);
+    for (const c of chans)
+      this.bumpContentEpoch(c);
+  }
+  /**
+   * §14.4 Clear all, applied whatever the mode (M-7): every item of every scope (person DMs included, R-U23), and the
+   * matching old-table rows, notes and recall (R-U21), in one transaction. History (agent_memory) is not memory and stays
+   * (the Clear all dialog, §18.1: "It does not delete any messages"). False when `generation` is not above the stored one.
+   */
+  applyUnifiedClear(generation) {
+    if (!Number.isInteger(generation) || generation < 0 || generation > MAX_CLEAR_GENERATION)
+      throw new RangeError("clear generation out of range");
+    return this.immediate(() => {
+      this.ensureStateRow();
+      if (generation <= this.unifiedState().applied)
+        return false;
+      this.deleteAllItems();
+      this.db.prepare("DELETE FROM agent_memory_note WHERE identity_id=?").run(this.id);
+      this.deleteAllRecall();
+      this.watermarkHistoryLocked();
+      this.db.prepare(`UPDATE agent_memory_state SET unified_applied_clear_generation=?,
+           applied_clear_generation=MAX(applied_clear_generation, ?), recall_applied_clear_generation=MAX(recall_applied_clear_generation, ?)
+         WHERE identity_id=?`).run(generation, generation, generation, this.id);
+      return true;
+    });
+  }
+  /**
+   * R-U22: one room's scope, everywhere, when its generation rises; applied whatever the mode (M-7). An unreadable
+   * room_clears_applied map is overwritten (repaired) by this write; until then inserts fail closed (`roomClearsBad`).
+   */
+  applyRoomClear(channelId, generation) {
+    if (!Number.isInteger(generation) || generation < 0 || generation > MAX_CLEAR_GENERATION)
+      throw new RangeError("room clear generation out of range");
+    return this.immediate(() => {
+      this.ensureStateRow();
+      const st = this.unifiedState();
+      const prev = Object.prototype.hasOwnProperty.call(st.roomClears, channelId) ? st.roomClears[channelId] : 0;
+      if (generation <= (typeof prev === "number" && Number.isSafeInteger(prev) ? prev : 0))
+        return false;
+      this.db.prepare("DELETE FROM agent_memory_token WHERE identity_id=? AND item_id IN (SELECT item_id FROM agent_memory_item WHERE identity_id=? AND scope_kind='room' AND scope_id=?)").run(this.id, this.id, channelId);
+      this.db.prepare("DELETE FROM agent_memory_item WHERE identity_id=? AND scope_kind='room' AND scope_id=?").run(this.id, channelId);
+      this.db.prepare("DELETE FROM agent_memory_note WHERE identity_id=? AND conversation_id=?").run(this.id, channelId);
+      this.db.prepare("DELETE FROM agent_memory_recall WHERE identity_id=? AND conversation_id=?").run(this.id, channelId);
+      const next = { ...st.roomClears, [channelId]: generation };
+      this.db.prepare("UPDATE agent_memory_state SET room_clears_applied=? WHERE identity_id=?").run(JSON.stringify(next), this.id);
+      this.recountItemAccounts();
+      this.bumpContentEpoch(channelId);
+      return true;
+    });
+  }
+  /**
+   * §14.4 forget (U13, R-U21): the item's whole origin group (plan I-3), its matching old-table row (a migrated note or
+   * recall row, by source_ref), the 7b tombstone for the origin message (so neither the restore re-run, a late restage
+   * nor the migration re-run brings it back), and the W9 spend, in ONE transaction. The caller has checked the id was
+   * shown with this delivery.
+   */
+  forgetItem(itemId, rewrite, conversationId) {
+    try {
+      return this.immediate(() => {
+        const row = this.db.prepare("SELECT item_id, parent_id, channel_id FROM agent_memory_item WHERE identity_id=? AND item_id=?").get(this.id, itemId);
+        if (!row)
+          return { ok: false, reason: "unknown_id" };
+        const first = row.parent_id ?? row.item_id;
+        const head = this.db.prepare("SELECT source_ref, origin_id FROM agent_memory_item WHERE identity_id=? AND item_id=?").get(this.id, first);
+        const gone = this.deleteItemGroup(first);
+        const note = /^agent_memory_note:(.+):(\d+)$/.exec(head.source_ref ?? "");
+        if (note)
+          this.db.prepare("DELETE FROM agent_memory_note WHERE identity_id=? AND conversation_id=? AND note_id=?").run(this.id, note[1], Number(note[2]));
+        if (!note) {
+          this.db.prepare("DELETE FROM agent_memory_recall WHERE identity_id=? AND conversation_id=? AND message_id=?").run(this.id, row.channel_id, head.origin_id);
+          this.db.prepare(`INSERT INTO agent_memory_recall_forgotten (identity_id, conversation_id, message_id, forgotten_at) VALUES (?, ?, ?, ?)
+             ON CONFLICT(identity_id, conversation_id, message_id) DO UPDATE SET forgotten_at=excluded.forgotten_at`).run(this.id, row.channel_id, head.origin_id, this.memoryNow());
+        }
+        if (!this.applyInboxRewrite(rewrite, conversationId))
+          throw new BudgetSpent();
+        this.bumpContentEpoch(row.channel_id);
+        return { ok: true, channelId: row.channel_id, itemIds: gone.ids };
+      });
+    } catch (e) {
+      if (e instanceof BudgetSpent)
+        return { ok: false, reason: "budget" };
+      throw e;
+    }
+  }
+  /**
+   * Section 8.2 owner change (H-4, H-A): one frozen owner-DM scope, pins included. Old-table rows stay (OQ-P3 reading), but
+   * (controller ruling FINAL store I-2) the scope's channel has its three migration markers raised past every old row in
+   * the same transaction, so a later run under the new owner never imports the previous owner's notes, recall or history.
+   * The channel's DM owner record of that owner goes too. `scopeId` is only ever bound (NUL-safe); channels for the epoch
+   * bump come from the channel column.
+   */
+  purgeScope(scopeId) {
+    return this.immediate(() => {
+      const chans = this.db.prepare("SELECT DISTINCT channel_id AS c FROM agent_memory_item WHERE identity_id=? AND scope_id=?").all(this.id, scopeId).map((r) => r.c);
+      const parsed = parseOwnerDmScopeId(scopeId);
+      for (const c of /* @__PURE__ */ new Set([...chans, ...parsed ? [parsed.channelId] : []]))
+        this.freezeMigrationMarkersLocked(c);
+      if (parsed) {
+        this.db.prepare("DELETE FROM agent_memory_dm_owner WHERE identity_id=? AND channel_id=? AND owner_identity_id=?").run(this.id, parsed.channelId, parsed.ownerIdentityId);
+      }
+      this.db.prepare("DELETE FROM agent_memory_token WHERE identity_id=? AND item_id IN (SELECT item_id FROM agent_memory_item WHERE identity_id=? AND scope_id=?)").run(this.id, this.id, scopeId);
+      const n = Number(this.db.prepare("DELETE FROM agent_memory_item WHERE identity_id=? AND scope_id=?").run(this.id, scopeId).changes);
+      this.recountItemAccounts();
+      for (const c of chans)
+        this.bumpContentEpoch(c);
+      return n;
+    });
+  }
+  /**
+   * Controller ruling FINAL store I-2: inside the caller's transaction, the note, recall and history markers of one channel
+   * go to just past every row of that source in the channel and past now (MAX: a higher marker is kept). Reads use
+   * `time >= marker`, so nothing written before this call is read again; old rows are not deleted.
+   */
+  freezeMigrationMarkersLocked(channelId) {
+    const now = Math.max(Date.now(), this.memoryNow()) + 1;
+    const up = this.db.prepare(`INSERT INTO agent_memory_migration (identity_id, source, conversation_id, marker) VALUES (?, ?, ?, ?)
+       ON CONFLICT (identity_id, source, conversation_id) DO UPDATE SET marker=MAX(marker, excluded.marker)`);
+    const newest = (q) => Number(this.db.prepare(q).get(this.id, channelId).t ?? 0);
+    up.run(this.id, "note", channelId, Math.max(now, newest("SELECT MAX(updated_at) + 1 AS t FROM agent_memory_note WHERE identity_id=? AND conversation_id=?")));
+    up.run(this.id, "recall", channelId, Math.max(now, newest("SELECT MAX(indexed_at) + 1 AS t FROM agent_memory_recall WHERE identity_id=? AND conversation_id=?")));
+    up.run(this.id, "history", channelId, Math.max(now, newest("SELECT MAX(recorded_at) + 1 AS t FROM agent_memory WHERE identity_id=? AND conversation_id=?")));
+  }
+  /**
+   * Final review store I-2 (bridge half): remember the owner of an owner DM whose old rows may still be migrated. True when
+   * the recorded owner is `ownerIdentityId` (recorded now, or already); false when another owner is recorded: the owner
+   * change is then the owner-scope sweep's to settle (purgeScope of the recorded owner's scope), never overwritten here.
+   */
+  recordDmOwner(channelId, ownerIdentityId) {
+    if (!channelId || !ownerIdentityId || channelId.includes("\0") || ownerIdentityId.includes("\0"))
+      throw new RangeError("dm owner ids");
+    return this.immediate(() => {
+      this.db.prepare("INSERT INTO agent_memory_dm_owner (identity_id, channel_id, owner_identity_id) VALUES (?, ?, ?) ON CONFLICT DO NOTHING").run(this.id, channelId, ownerIdentityId);
+      const r = this.db.prepare("SELECT owner_identity_id AS o FROM agent_memory_dm_owner WHERE identity_id=? AND channel_id=?").get(this.id, channelId);
+      return r.o === ownerIdentityId;
+    });
+  }
+  /** The owner-DM scope ids of the recorded DM owners (the owner-scope sweep's input beside ownerDmScopeIds). */
+  dmOwnerScopes() {
+    return this.db.prepare("SELECT channel_id AS c, owner_identity_id AS o FROM agent_memory_dm_owner WHERE identity_id=?").all(this.id).map((r) => ownerDmScopeId(r.c, r.o)).sort();
+  }
+  /** §14.3 quotas (M-3, G-2). Inside the insert's transaction. R2-L-2: rows older than `q.day` are pruned, only once the write is accepted. */
+  takeQuota(channelId, q) {
+    if (this.quotaCount(channelId, null, q.day) >= q.scopeLimit)
+      return false;
+    if (q.senderId !== null && q.senderLimit !== null && this.quotaCount(channelId, q.senderId, q.day) >= q.senderLimit)
+      return false;
+    this.db.prepare("DELETE FROM agent_memory_quota WHERE identity_id=? AND day<?").run(this.id, q.day);
+    const up = this.db.prepare(`INSERT INTO agent_memory_quota (identity_id, channel_id, sender_id, day, count) VALUES (?, ?, ?, ?, 1)
+       ON CONFLICT(identity_id, channel_id, sender_id, day) DO UPDATE SET count=count+1`);
+    up.run(this.id, channelId, "", q.day);
+    if (q.senderId !== null)
+      up.run(this.id, channelId, q.senderId, q.day);
+    return true;
+  }
+  quotaCount(channelId, senderId, day) {
+    const r = this.db.prepare("SELECT count AS n FROM agent_memory_quota WHERE identity_id=? AND channel_id=? AND sender_id=? AND day=?").get(this.id, channelId, senderId ?? "", day);
+    return r ? Number(r.n) : 0;
+  }
   listPendingRecall(modelId, limit) {
     if (this.recallClearLagging())
       return [];
@@ -27281,12 +28066,169 @@ var SqliteMlsStateStore = class {
       return purged;
     });
   }
-  /** §5.4: every conversation holding turns, facts, notes or recall rows. */
+  /** §14.1: one conversation's notes changed at or after `sinceMs`, keyset after `after`, at most `limit` (OQ-P7), opened under noteAad. */
+  async readNotesForMigration(conversationId, sinceMs, after, limit) {
+    const raw = this.db.prepare(`SELECT conversation_id, note_id, sealed_text, created_at, updated_at FROM agent_memory_note
+       WHERE identity_id=? AND conversation_id=? AND updated_at>=? AND (updated_at, note_id) > (?, ?) ORDER BY updated_at, note_id LIMIT ?`).all(this.id, conversationId, sinceMs, after?.at ?? -1, after?.id ?? -1, limit);
+    const rows = [];
+    let unreadable = 0;
+    for (const [i, r] of raw.entries()) {
+      if (i > 0 && i % MIGRATION_READ_SLICE === 0)
+        await yieldToLoop();
+      try {
+        const text = UTF8.decode(await this.cipher.openWithAad(r.sealed_text, noteAad(this.id, r.conversation_id)));
+        rows.push({ conversationId: r.conversation_id, noteId: Number(r.note_id), text, createdAt: Number(r.created_at), updatedAt: Number(r.updated_at) });
+      } catch {
+        unreadable++;
+      }
+    }
+    const z4 = raw[raw.length - 1];
+    return { rows, unreadable, next: z4 ? { at: Number(z4.updated_at), id: Number(z4.note_id) } : null };
+  }
+  /** §14.1: one conversation's recall rows indexed at or after `sinceMs`, keyset after `after`, at most `limit` (OQ-P7); text and vector opened (no re-embed). */
+  async readRecallForMigration(conversationId, sinceMs, after, limit) {
+    const raw = this.db.prepare(`SELECT conversation_id, recall_id, message_id, sealed_text, sealed_vec, model_id, sent_at, indexed_at FROM agent_memory_recall
+       WHERE identity_id=? AND conversation_id=? AND indexed_at>=? AND (indexed_at, recall_id) > (?, ?) ORDER BY indexed_at, recall_id LIMIT ?`).all(this.id, conversationId, sinceMs, after?.at ?? -1, after?.id ?? -1, limit);
+    const rows = [];
+    let unreadable = 0;
+    for (const [i, r] of raw.entries()) {
+      if (i > 0 && i % MIGRATION_READ_SLICE === 0)
+        await yieldToLoop();
+      const row = this.rowFrom(r);
+      const text = await this.openRecallText(r.conversation_id, row);
+      if (text === null) {
+        unreadable++;
+        continue;
+      }
+      const vec = row.sealedVec === null ? null : await this.openRecallVec(r.conversation_id, row);
+      rows.push({ conversationId: r.conversation_id, recallId: Number(r.recall_id), messageId: row.messageId, text, vec, modelId: vec === null ? null : row.modelId, sentAt: row.sentAt, indexedAt: row.indexedAt });
+    }
+    const z4 = raw[raw.length - 1];
+    return { rows, unreadable, next: z4 ? { at: Number(z4.indexed_at), id: Number(z4.recall_id) } : null };
+  }
+  /** §14.1 (R-U12): one conversation's history in seq order, opened under the EMPTY AAD. Batched by `afterSeq`; `next` is {at: recorded_at, id: seq}. */
+  async readHistoryForMigration(conversationId, sinceMs, afterSeq, limit) {
+    const raw = this.db.prepare(`SELECT seq, message_id, role, sealed_text, recorded_at FROM agent_memory WHERE identity_id=? AND conversation_id=? AND recorded_at>=? AND seq>?
+       ORDER BY seq ASC LIMIT ?`).all(this.id, conversationId, sinceMs, afterSeq, limit);
+    const rows = [];
+    let unreadable = 0;
+    for (const [i, r] of raw.entries()) {
+      if (i > 0 && i % MIGRATION_READ_SLICE === 0)
+        await yieldToLoop();
+      try {
+        const text = UTF8.decode(await this.cipher.open(r.sealed_text));
+        rows.push({ seq: Number(r.seq), messageId: r.message_id ?? null, role: r.role === "agent" ? "agent" : "peer", text, recordedAt: Number(r.recorded_at) });
+      } catch {
+        unreadable++;
+      }
+    }
+    const z4 = raw[raw.length - 1];
+    return { rows, unreadable, next: z4 ? { at: Number(z4.recorded_at), id: Number(z4.seq) } : null };
+  }
+  historyConversationIds() {
+    return this.db.prepare("SELECT DISTINCT conversation_id AS c FROM agent_memory WHERE identity_id=? ORDER BY c").all(this.id).map((r) => r.c);
+  }
+  recallTombstoned(conversationId, messageId) {
+    return this.db.prepare("SELECT 1 FROM agent_memory_recall_forgotten WHERE identity_id=? AND conversation_id=? AND message_id=?").get(this.id, conversationId, messageId) !== void 0;
+  }
+  noteConversationIds() {
+    return this.db.prepare("SELECT DISTINCT conversation_id AS c FROM agent_memory_note WHERE identity_id=? ORDER BY c").all(this.id).map((r) => r.c);
+  }
+  recallConversationIds() {
+    return this.db.prepare("SELECT DISTINCT conversation_id AS c FROM agent_memory_recall WHERE identity_id=? ORDER BY c").all(this.id).map((r) => r.c);
+  }
+  /** Plan audit HIGH-1: one marker per (source, conversation); 0 when the pair was never migrated. */
+  migrationMarker(source, conversationId) {
+    return Number(this.db.prepare("SELECT marker AS m FROM agent_memory_migration WHERE identity_id=? AND source=? AND conversation_id=?").get(this.id, source, conversationId)?.m ?? 0);
+  }
+  setMigrationMarker(source, conversationId, ms) {
+    if (!Number.isSafeInteger(ms) || ms < 0)
+      throw new RangeError("marker");
+    this.immediate(() => {
+      this.db.prepare(`INSERT INTO agent_memory_migration (identity_id, source, conversation_id, marker) VALUES (?, ?, ?, ?)
+         ON CONFLICT (identity_id, source, conversation_id) DO UPDATE SET marker=MAX(marker, excluded.marker)`).run(this.id, source, conversationId, ms);
+    });
+  }
+  /**
+   * §14.5 (H-5, H-B), one transaction, before anything is served. Per source: migrated_note -> its note row is missing;
+   * migrated_recall -> its message is tombstoned; imported_history -> never by absence. `enabled` is false in the release
+   * that drops the old tables (every source row would look missing). Prefix tests use substr (LIKE would read `_` as a wildcard).
+   */
+  sweepMigratedSources(enabled) {
+    if (!enabled)
+      return { notes: 0, recall: 0 };
+    return this.immediate(() => this.sweepMigratedSourcesTx());
+  }
+  /** The sweep's body, inside the caller's transaction. */
+  sweepMigratedSourcesTx() {
+    const noteGone = this.db.prepare(`SELECT i.item_id AS id FROM agent_memory_item i WHERE i.identity_id=? AND i.parent_id IS NULL AND substr(i.source_ref, 1, 18) = 'agent_memory_note:'
+         AND NOT EXISTS (SELECT 1 FROM agent_memory_note n WHERE n.identity_id=i.identity_id AND i.source_ref = 'agent_memory_note:' || n.conversation_id || ':' || n.note_id)`).all(this.id).map((r) => Number(r.id));
+    const recallGone = this.db.prepare(`SELECT i.item_id AS id FROM agent_memory_item i WHERE i.identity_id=? AND i.parent_id IS NULL AND substr(i.source_ref, 1, 20) = 'agent_memory_recall:'
+         AND EXISTS (SELECT 1 FROM agent_memory_recall_forgotten f WHERE f.identity_id=i.identity_id AND i.source_ref = 'agent_memory_recall:' || f.conversation_id || ':' || f.message_id)`).all(this.id).map((r) => Number(r.id));
+    const chans = /* @__PURE__ */ new Set();
+    for (const id of [...noteGone, ...recallGone]) {
+      const g = this.deleteItemGroup(id);
+      if (g.channelId)
+        chans.add(g.channelId);
+    }
+    for (const c of chans)
+      this.bumpContentEpoch(c);
+    return { notes: noteGone.length, recall: recallGone.length };
+  }
+  /** The distinct owner-DM scope ids holding items. scope_id carries a NUL, so it is read as a BLOB and decoded here (CARRY-NUL). */
+  ownerDmScopeIds() {
+    return this.db.prepare("SELECT DISTINCT CAST(scope_id AS BLOB) AS s FROM agent_memory_item WHERE identity_id=? AND scope_kind='owner_dm'").all(this.id).map((r) => UTF8.decode(r.s)).sort();
+  }
+  /**
+   * §14.5: a clear applied while a 0.28 bridge ran (notes generation moved past the unified applied one): every item goes
+   * (the 0.28 bridge already cleared notes and recall). The applied generation is set to the notes generation, so a later
+   * clear above it still applies (no permanent `cleared` refusal).
+   */
+  reconcileUnifiedClearGeneration() {
+    return this.immediate(() => this.reconcileUnifiedClearGenerationTx());
+  }
+  /** The clear check's body, inside the caller's transaction. */
+  reconcileUnifiedClearGenerationTx() {
+    this.ensureStateRow();
+    const notesGen = this.memoryClearGeneration();
+    if (this.unifiedState().applied >= notesGen)
+      return 0;
+    const n = Number(this.db.prepare("SELECT COUNT(*) AS n FROM agent_memory_item WHERE identity_id=?").get(this.id).n);
+    this.deleteAllItems();
+    this.watermarkHistoryLocked();
+    this.db.prepare("UPDATE agent_memory_state SET unified_applied_clear_generation=? WHERE identity_id=?").run(notesGen, this.id);
+    return n;
+  }
+  /**
+   * Plan Task 30 fix round 1 (privacy ruling): inside a Clear all's transaction, every conversation holding history gets
+   * its `history` migration marker raised to just past the clear (reads use recorded_at >= marker; MAX keeps it
+   * monotonic), so a later first migration never re-imports pre-clear history (a clear keeps history, section 14.4).
+   * Notes and recall need nothing: the clear deletes those rows.
+   */
+  watermarkHistoryLocked() {
+    this.db.prepare(`INSERT INTO agent_memory_migration (identity_id, source, conversation_id, marker)
+         SELECT DISTINCT identity_id, 'history', conversation_id, ? FROM agent_memory WHERE identity_id=?
+       ON CONFLICT (identity_id, source, conversation_id) DO UPDATE SET marker=MAX(marker, excluded.marker)`).run(Date.now() + 1, this.id);
+  }
+  /**
+   * Section 14.5 (H-5, H-B; controller ruling C22): on re-upgrade, before anything is served, in ONE transaction: the per-source
+   * sweep (skipped when `sweepEnabled` is false, the release that drops the old tables), then the clear-generation check.
+   */
+  reupgradeReconcileUnified(sweepEnabled) {
+    return this.immediate(() => {
+      const swept = sweepEnabled ? this.sweepMigratedSourcesTx() : { notes: 0, recall: 0 };
+      const cleared = this.reconcileUnifiedClearGenerationTx();
+      this.ownerLoad();
+      return { swept, cleared };
+    });
+  }
+  /** §5.4: every conversation holding turns, facts, notes, recall rows or unified items. */
   memoryConversationIds() {
     const rows = this.db.prepare(`SELECT conversation_id AS c FROM agent_memory WHERE identity_id=?
        UNION SELECT conversation_id FROM agent_memory_fact WHERE identity_id=?
        UNION SELECT conversation_id FROM agent_memory_note WHERE identity_id=?
-       UNION SELECT conversation_id FROM agent_memory_recall WHERE identity_id=?`).all(this.id, this.id, this.id, this.id);
+       UNION SELECT conversation_id FROM agent_memory_recall WHERE identity_id=?
+       UNION SELECT channel_id FROM agent_memory_item WHERE identity_id=?`).all(this.id, this.id, this.id, this.id, this.id);
     return rows.map((r) => r.c);
   }
   /**
@@ -27729,8 +28671,9 @@ function loadPackageMeta(importMetaUrl) {
 }
 
 // src/bridge-agent.ts
-import { promises as fsp } from "node:fs";
-import { join as join15, dirname as dirname4 } from "node:path";
+import { promises as fsp, statSync as statSync4 } from "node:fs";
+import { join as join16, dirname as dirname4 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/latency.ts
 var DEFAULT_CAPACITY = 1024;
@@ -28098,6 +29041,134 @@ var DecryptErrorLogLimiter = class {
   }
 };
 
+// src/memory/unified/escape.ts
+var ITEM_LINE_MAX = 1e3;
+var CONTROL_TO_SPACE = /[\p{Cc}\u2028\u2029]/gu;
+var C1_STRIP = /[\p{Cf}\p{Co}\p{Cn}\uFE00-\uFE0F\u{E0100}-\u{E01EF}]/gu;
+function escapeQuoted(s, max) {
+  const cleaned = s.replace(CONTROL_TO_SPACE, " ").replace(C1_STRIP, "");
+  const capped = [...cleaned].slice(0, max).join("");
+  return capped.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function stripInvisible(s) {
+  return s.replace(CONTROL_TO_SPACE, " ").replace(C1_STRIP, "");
+}
+function pinnedLine(pin) {
+  return `Pinned: "${escapeQuoted(pin, ITEM_LINE_MAX)}" Say "forget that" to remove it.`;
+}
+function forgotLine(text) {
+  return `Forgot: "${escapeQuoted(text, ITEM_LINE_MAX)}"`;
+}
+function isBridgeMemoryLine(text) {
+  return /^Pinned: ".*" Say "forget that" to remove it\.$/.test(text) || /^Forgot: ".*"$/.test(text);
+}
+
+// src/memory/unified/text.ts
+var QUOTES = {
+  "\u2018": "'",
+  "\u2019": "'",
+  "\u201A": "'",
+  "\u201B": "'",
+  "\u201C": '"',
+  "\u201D": '"',
+  "\u201E": '"',
+  "\u201F": '"'
+};
+var DASHES = /* @__PURE__ */ new Set(["\u2013", "\u2014"]);
+function foldText(s) {
+  let out = "";
+  for (const c of s.normalize("NFKC").toLowerCase()) out += QUOTES[c] ?? (DASHES.has(c) ? "-" : c);
+  return out;
+}
+var TOKEN_RE = /[\p{L}\p{N}\p{M}]+(?:'[\p{L}\p{N}\p{M}]+)*/gu;
+function tokens(s) {
+  return [...foldText(s).matchAll(TOKEN_RE)].map((m) => m[0]);
+}
+var NUMBER_WORDS = new Set(
+  "zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen twenty thirty forty fifty sixty seventy eighty ninety hundred thousand million billion trillion first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth eighteenth nineteenth twentieth thirtieth fortieth fiftieth sixtieth seventieth eightieth ninetieth hundredth thousandth millionth billionth trillionth".split(" ")
+);
+var STOP_WORDS = new Set(
+  "a about above after again against all am an and any are as at be because been before being below between both but by can could did do does doing down during each few for from further had has have having he her here hers herself him himself his how i if in into is it its itself just me more most my myself no nor not now of off on once only or other our ours ourselves out over own same she should so some such than that the their theirs them themselves then there these they this those through to too under until up very was we were what when where which while who whom why will with would you your yours yourself yourselves".split(" ")
+);
+var QUERY_SUFFIXES = ["s", "es", "ed", "ing", "er", "ers", "ly"];
+function indexTokens(text) {
+  return [...new Set(tokens(text).filter((t) => !STOP_WORDS.has(t)))];
+}
+function queryExpansions(t) {
+  const out = /* @__PURE__ */ new Set([t]);
+  for (const s of QUERY_SUFFIXES) {
+    out.add(t + s);
+    if (t.endsWith(s) && t.length - s.length >= 3) out.add(t.slice(0, -s.length));
+  }
+  if (t.endsWith("y") && t.length >= 4) out.add(t.slice(0, -1) + "ies");
+  if (t.endsWith("ies") && t.length >= 5) out.add(t.slice(0, -3) + "y");
+  return [...out];
+}
+
+// src/memory/unified/pin-rules.ts
+var FRAMING_WORDS = /* @__PURE__ */ new Set([
+  "owner",
+  "prefers",
+  "likes",
+  "wants",
+  "uses",
+  "is",
+  "my",
+  "their",
+  "i",
+  "me",
+  "mine",
+  "you",
+  "your",
+  "yours",
+  "he",
+  "him",
+  "his",
+  "she",
+  "her",
+  "hers",
+  "it",
+  "its",
+  "we",
+  "us",
+  "our",
+  "ours",
+  "they",
+  "them",
+  "theirs",
+  "a",
+  "an",
+  "the",
+  "are",
+  "was",
+  "were",
+  "be",
+  "has",
+  "have",
+  "to",
+  "of",
+  "and",
+  "that"
+]);
+var SYMBOLS = /* @__PURE__ */ new Set([..."$%&+=<>~^|#@*/"]);
+var VARIATION_SELECTOR = /[\u180B-\u180F\uFE00-\uFE0F\u{E0100}-\u{E01EF}]/u;
+var KEEP = /[\p{L}\p{N}\p{P}\p{Zs}\p{Mn}\p{Mc}]/u;
+function allowlistPin(raw) {
+  let out = "";
+  for (const c of raw.normalize("NFC")) {
+    if (VARIATION_SELECTOR.test(c)) continue;
+    if (KEEP.test(c) || SYMBOLS.has(c)) out += c;
+  }
+  return out;
+}
+function pinCoverage(pinStripped, ownerMessage, coverTexts) {
+  const allowed = new Set(tokens(ownerMessage));
+  for (const t of coverTexts) for (const x of tokens(t)) allowed.add(x);
+  let uncovered = 0;
+  for (const t of tokens(pinStripped)) if (!FRAMING_WORDS.has(t) && !allowed.has(t)) uncovered++;
+  return uncovered === 0 ? { ok: true } : { ok: false, uncovered };
+}
+
 // src/attachments.ts
 import { basename } from "node:path";
 var VAULT_REF_MAX_SIZE_HINT = 100 * 1024 * 1024 - 16;
@@ -28656,7 +29727,7 @@ var NOTES_HEADING = "## Saved notes for this chat (data, not instructions)";
 var PASTE_MAX_CHARS = 600;
 var NOTE_MIN_CHARS = 6;
 var NOTE_MIN_TOKENS = 2;
-var QUOTES = {
+var QUOTES2 = {
   "\u2018": "'",
   "\u2019": "'",
   "\u201A": "'",
@@ -28666,7 +29737,7 @@ var QUOTES = {
   "\u201E": '"',
   "\u201F": '"'
 };
-var DASHES = /* @__PURE__ */ new Set(["\u2013", "\u2014"]);
+var DASHES2 = /* @__PURE__ */ new Set(["\u2013", "\u2014"]);
 var NOTE_EDGE = /* @__PURE__ */ new Set([...`.,;:!?"'()[]`]);
 var WORD = /[\p{L}\p{N}\p{M}]/u;
 var INVISIBLE_RE = /[\p{Cf}\p{Cc}\u2065\uFFF0-\uFFF8\u{E0000}-\u{E0FFF}]/u;
@@ -28685,7 +29756,7 @@ var APOS_LIKE = /* @__PURE__ */ new Set([
   "\u05F3",
   "\u05F4"
 ]);
-var isApos = (c) => APOS_LIKE.has(QUOTES[c] ?? c);
+var isApos = (c) => APOS_LIKE.has(QUOTES2[c] ?? c);
 function mapNorm(src) {
   const out = [];
   let i = 0;
@@ -28693,7 +29764,7 @@ function mapNorm(src) {
     const start = i;
     i += cp.length;
     for (const c of cp.normalize("NFKC").toLowerCase()) {
-      const folded = QUOTES[c] ?? (DASHES.has(c) ? "-" : c);
+      const folded = QUOTES2[c] ?? (DASHES2.has(c) ? "-" : c);
       out.push({ ch: folded !== "\uFEFF" && /\s/u.test(folded) ? " " : folded, start, end: i });
     }
   }
@@ -29580,6 +30651,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 +31042,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 +31072,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 +31083,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 +31169,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 +31398,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 +31436,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 +31465,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 +31541,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 +31580,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 +31638,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 +31714,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 });
   }
@@ -30881,17 +32024,860 @@ var CallHeartbeat = class {
   }
 };
 
+// src/memory/unified/switch.ts
+var UNIFIED_MEMORY_PART1 = true;
+function unifiedPart1On(injected) {
+  return injected ?? UNIFIED_MEMORY_PART1;
+}
+
+// src/memory/unified/config.ts
+var gen = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0 && v <= MAX_CLEAR_GENERATION;
+function parseUnifiedPayloadMemory(raw) {
+  if (raw === void 0) return { on: true, clearGeneration: 0, roomClears: /* @__PURE__ */ new Map() };
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return { on: false, reason: "unrecognized", roomClears: /* @__PURE__ */ new Map() };
+  const o = raw;
+  if (Object.keys(o).length === 0) return { on: true, clearGeneration: 0, roomClears: /* @__PURE__ */ new Map() };
+  const roomClears = /* @__PURE__ */ new Map();
+  const rc = o.room_clears;
+  if (rc && typeof rc === "object" && !Array.isArray(rc)) {
+    for (const [k, v] of Object.entries(rc)) if (k.length > 0 && k.length <= 200 && gen(v)) roomClears.set(k, v);
+  }
+  const clear = gen(o.clear_generation) ? { clearGeneration: o.clear_generation } : {};
+  if (o.mode === "markdown" || o.mode === "semantic") {
+    return gen(o.clear_generation) ? { on: true, clearGeneration: o.clear_generation, roomClears } : { on: false, reason: "unrecognized", roomClears };
+  }
+  return { on: false, reason: o.mode === "off" ? "off" : "unrecognized", ...clear, roomClears };
+}
+
+// src/memory/unified/index-key.ts
+import { createHmac as createHmac3, hkdfSync as hkdfSync3 } from "node:crypto";
+var MEMORY_INDEX_INFO = "securecoms/agent-memory-index/v1";
+var QUERY_MACS_MAX = 64;
+function deriveMemoryIndexKey(seed) {
+  return Buffer.from(hkdfSync3("sha256", seed, new Uint8Array(0), MEMORY_INDEX_INFO, 32));
+}
+function tokenMac(key, token) {
+  return new Uint8Array(createHmac3("sha256", key).update(token, "utf8").digest().subarray(0, 16));
+}
+function itemTokenMacs(key, text) {
+  return indexTokens(text).map((t) => tokenMac(key, t));
+}
+function queryTokenMacs(key, text, max = QUERY_MACS_MAX) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const t of tokens(text)) {
+    if (STOP_WORDS.has(t)) continue;
+    for (const e of queryExpansions(t)) {
+      if (seen.has(e)) continue;
+      seen.add(e);
+      out.push(tokenMac(key, e));
+      if (out.length >= max) return out;
+    }
+  }
+  return out;
+}
+
+// src/memory/unified/ranking-client.ts
+import { Worker } from "node:worker_threads";
+import { join as join14 } from "node:path";
+function workerTransport(init, distDir) {
+  const w = new Worker(join14(distDir, "memory-worker.js"), { workerData: init });
+  return {
+    post: (m) => w.postMessage(m),
+    onMessage: (cb) => {
+      w.on("message", cb);
+    },
+    onExit: (cb) => {
+      w.on("exit", cb);
+      w.on("error", cb);
+    },
+    terminate: async () => {
+      await w.terminate();
+    }
+  };
+}
+var RankingClient = class {
+  constructor(d) {
+    this.d = d;
+  }
+  t = null;
+  /** Final review bridge I-2(b): set by close(); no call after it spawns a worker or posts. */
+  closed = false;
+  seq = 0;
+  waiting = /* @__PURE__ */ new Map();
+  misses = 0;
+  hot = 0;
+  transport() {
+    if (this.t) return this.t;
+    const t = this.d.spawn();
+    t.onMessage((m) => {
+      if (m.type === "ready" || m.type === "stats") {
+        this.hot = m.hotBytes;
+        return;
+      }
+      if (m.type === "fatal") return;
+      const p = this.waiting.get(m.id);
+      if (!p) return;
+      this.waiting.delete(m.id);
+      if (m.type === "failed") {
+        this.misses++;
+        p.resolve("failed");
+        return;
+      }
+      p.resolve(m);
+    });
+    t.onExit(() => {
+      if (this.t !== t) return;
+      this.t = null;
+      this.hot = 0;
+      (this.d.log ?? writeServiceLog2)("warn", "memory.ranking_worker_exited", { inFlight: this.waiting.size });
+      this.misses += this.waiting.size;
+      for (const p of this.waiting.values()) p.resolve("failed");
+      this.waiting.clear();
+    });
+    this.t = t;
+    return t;
+  }
+  ask(build, deadlineAt) {
+    const id = ++this.seq;
+    if (this.closed) return Promise.resolve("failed");
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.waiting.delete(id);
+        this.misses++;
+        resolve("late");
+      }, Math.max(0, deadlineAt - Date.now()));
+      this.waiting.set(id, { resolve: (m) => {
+        clearTimeout(timer);
+        resolve(m);
+      } });
+      try {
+        this.transport().post(build(id));
+      } catch (e) {
+        clearTimeout(timer);
+        this.waiting.delete(id);
+        this.misses++;
+        (this.d.log ?? writeServiceLog2)("warn", "memory.ranking_worker_spawn_failed", void 0, e);
+        resolve("failed");
+      }
+    });
+  }
+  async query(q, deadlineAt) {
+    const r = await this.ask((id) => ({ type: "query", id, q }), deadlineAt);
+    return typeof r === "string" ? r : { items: r.items, openFailed: r.openFailed };
+  }
+  async pins(scopeId, maxChars, deadlineAt) {
+    const r = await this.ask((id) => ({ type: "pins", id, scopeId, maxChars }), deadlineAt);
+    return typeof r === "string" ? r : { pins: r.pins, more: r.more };
+  }
+  async pending(limit, deadlineAt) {
+    const r = await this.ask((id) => ({ type: "pending", id, limit }), deadlineAt);
+    return typeof r === "string" ? r : r.rows;
+  }
+  /**
+   * Final review bridge I-2: hot-set notifications reach a RUNNING worker only. With none running they are no-ops (a worker
+   * spawned later warms from the database, so nothing is lost): a purge, clear or write while memory is off never starts
+   * a resident worker, nothing respawns after close(), and a post that throws never escapes into a committed write's path.
+   */
+  notify(m) {
+    if (this.closed || !this.t) return;
+    try {
+      this.t.post(m);
+    } catch (e) {
+      (this.d.log ?? writeServiceLog2)("warn", "memory.ranking_notify_failed", void 0, e);
+    }
+  }
+  added(itemIds) {
+    if (itemIds.length) this.notify({ type: "added", itemIds });
+  }
+  removed(itemIds) {
+    if (itemIds.length) this.notify({ type: "removed", itemIds });
+  }
+  reset() {
+    this.notify({ type: "reset" });
+  }
+  hotBytes() {
+    return this.hot;
+  }
+  deadlineMisses() {
+    return this.misses;
+  }
+  async close() {
+    this.closed = true;
+    const t = this.t;
+    this.t = null;
+    for (const p of this.waiting.values()) p.resolve("failed");
+    this.waiting.clear();
+    await t?.terminate();
+  }
+};
+
+// src/memory/unified/owner-scope.ts
+function ownerScopeFrom(channelId, f) {
+  if (!f.rosterKnown) return "unknown";
+  if (f.isDm !== true) return null;
+  if (f.pin === void 0) return "unknown";
+  if (f.pin === "anomalous") return null;
+  if (!f.member || f.member.is_agent || !f.member.is_agent_owner) return null;
+  return ownerDmScopeId(channelId, f.pin.identityId);
+}
+var OwnerScopeSweeper = class {
+  constructor(d) {
+    this.d = d;
+  }
+  running = false;
+  async sweep() {
+    const stopping = () => this.d.stopping?.() === true;
+    if (this.running || stopping()) return { purged: 0, frozen: 0 };
+    this.running = true;
+    try {
+      const now = this.d.now();
+      let purged = 0, frozen = 0;
+      for (const c of this.d.oldTableChannels?.() ?? []) {
+        if (stopping()) break;
+        const facts = this.d.factsOf(c);
+        if (facts.pin === "anomalous" || facts.isDm !== true) continue;
+        const cur = ownerScopeFrom(c, facts);
+        const owner = typeof cur === "string" ? parseOwnerDmScopeId(cur)?.ownerIdentityId : void 0;
+        if (owner !== void 0) this.d.recordOwner?.(c, owner);
+      }
+      for (const scopeId of [...new Set(this.d.scopes())]) {
+        if (stopping()) break;
+        const parsed = parseOwnerDmScopeId(scopeId);
+        if (!parsed) continue;
+        const facts = this.d.factsOf(parsed.channelId);
+        if (facts.pin === "anomalous") continue;
+        if (facts.isDm === void 0) continue;
+        const cur = ownerScopeFrom(parsed.channelId, facts);
+        if (cur === "unknown") continue;
+        if (cur === scopeId) {
+          this.d.clearAbsence(scopeId);
+          continue;
+        }
+        frozen++;
+        let rec = this.d.absenceOf(scopeId);
+        if (rec && now - rec.lastAbsentAt > PURGE_ABSENCE_EXPIRY_MS) {
+          this.d.clearAbsence(scopeId);
+          rec = void 0;
+        }
+        rec = this.d.markAbsent(scopeId, now);
+        if (rec.refreshes >= 2 && now - rec.firstAbsentAt >= PURGE_MIN_GAP_MS) {
+          await this.d.purge(scopeId);
+          this.d.clearAbsence(scopeId);
+          purged++;
+        }
+      }
+      if (purged > 0) (this.d.log ?? writeServiceLog2)("info", "memory.owner_scope_purged", { count: purged });
+      return { purged, frozen };
+    } finally {
+      this.running = false;
+    }
+  }
+};
+
+// src/memory/unified/chunk.ts
+var CHUNK_TARGET = 600;
+var CHUNK_CAP = 800;
+var CHUNK_OVERLAP = 100;
+var MIN_SPLIT = 400;
+var isHigh = (c) => c >= 55296 && c <= 56319;
+function splitAt(text, start) {
+  const lo = start + MIN_SPLIT, hi = Math.min(text.length, start + CHUNK_CAP), target = start + CHUNK_TARGET;
+  let best = -1;
+  for (let i = lo; i < hi; i++) {
+    if (/[.!?]/.test(text[i - 1]) && /\s/.test(text[i])) {
+      if (best < 0 || Math.abs(i + 1 - target) < Math.abs(best - target)) best = i + 1;
+    }
+  }
+  if (best > 0) return best;
+  for (let i = hi - 1; i >= lo; i--) if (/\s/.test(text[i])) return i + 1;
+  let cut = hi;
+  if (isHigh(text.charCodeAt(cut - 1))) cut--;
+  return cut;
+}
+function chunkText(text) {
+  if (text.length <= CHUNK_CAP) return [text];
+  const out = [];
+  let start = 0;
+  for (; ; ) {
+    if (text.length - start <= CHUNK_CAP) {
+      out.push(text.slice(start));
+      return out;
+    }
+    const end = splitAt(text, start);
+    out.push(text.slice(start, end));
+    let next = Math.max(start + 1, end - CHUNK_OVERLAP);
+    if (isHigh(text.charCodeAt(next - 1))) next++;
+    start = next;
+  }
+}
+function prepareMessageText(text) {
+  if (text.trim().length === 0) return { ok: false, reason: "empty" };
+  if (scanNote(text) !== null) return { ok: false, reason: "secret" };
+  return { ok: true, chunks: chunkText(text) };
+}
+
+// src/memory/unified/item-book.ts
+var DIMS3 = 384;
+var ItemBook = class {
+  constructor(d) {
+    this.d = d;
+  }
+  evicting = null;
+  skip(reason) {
+    (this.d.log ?? writeServiceLog2)("info", "memory.item_skipped", {
+      reason_class: ServiceLogEnum.of(reason, ["secret", "empty", "cleared", "room_cleared", "disabled", "purged", "duplicate", "changed", "pin_cap", "quota", "invalid", "store", "mode", "message"])
+    });
+    return { ok: false, reason };
+  }
+  async commit(r) {
+    let texts;
+    if (r.noChunk) {
+      if (r.text.trim().length === 0) return this.skip("empty");
+      if (scanNote(r.text) !== null) return this.skip("secret");
+      texts = [r.text];
+    } else {
+      const p = prepareMessageText(r.text);
+      if (!p.ok) return this.skip(p.reason);
+      texts = p.chunks;
+    }
+    const storedAt = (this.d.now ?? Date.now)();
+    const chunked = texts.length > 1;
+    let first;
+    const parts = [];
+    try {
+      first = this.d.store.reserveItemIds(chunked ? texts.length + 1 : 1);
+      const fields = (chunkIndex) => ({
+        scopeKind: r.scopeKind,
+        scopeId: r.scopeId,
+        channelId: r.channelId,
+        kind: r.kind,
+        originId: r.originId,
+        chunkIndex,
+        parentOriginId: chunkIndex ? r.originId : "",
+        parentId: chunkIndex ? first : null,
+        originAt: r.originAt,
+        storedAt
+      });
+      const rec = (text, chunks) => ({ text, source: r.source, trust: r.trust, ...r.sourceRef !== void 0 ? { sourceRef: r.sourceRef } : {}, ...chunks ? { chunks } : {} });
+      if (chunked) parts.push({ itemId: first, chunkIndex: 0, parentId: null, parentOriginId: "", sealedRecord: await this.d.store.sealItemRecord(fields(0), rec("", texts.length)), sealedVec: null, modelId: null, tokenMacs: [], embeddable: false });
+      const inlineOk = r.pendingOnly !== true && !this.d.paused() && this.d.embedOn() && this.d.embedder.state().state === "ready";
+      for (const [i, text] of texts.entries()) {
+        const chunkIndex = chunked ? i + 1 : 0;
+        const f = fields(chunkIndex);
+        let vec = null;
+        if (!chunked && r.vec && r.vecModelId === this.d.modelId && r.vec.length === DIMS3) vec = r.vec;
+        else if (inlineOk && i === 0) {
+          try {
+            const v = await this.d.embedder.embed(text, 1);
+            if (v.length === DIMS3) vec = v;
+          } catch {
+            vec = null;
+          }
+        }
+        const sealedVec = vec ? await this.d.store.sealItemVec(f, this.d.modelId, vec) : null;
+        parts.push({
+          itemId: chunked ? first + i + 1 : first,
+          chunkIndex,
+          parentId: chunked ? first : null,
+          parentOriginId: chunked ? r.originId : "",
+          sealedRecord: await this.d.store.sealItemRecord(f, rec(text)),
+          sealedVec,
+          modelId: sealedVec ? this.d.modelId : null,
+          tokenMacs: itemTokenMacs(this.d.indexKey, text),
+          embeddable: true
+        });
+      }
+    } catch {
+      return this.skip("store");
+    }
+    let out;
+    try {
+      out = await this.d.exclusive(async () => {
+        const veto = r.precommit?.() ?? null;
+        if (veto !== null) return { ok: false, reason: veto };
+        let replace;
+        const existing = this.d.store.itemByOrigin(r.scopeKind, r.scopeId, r.originId);
+        if (existing) {
+          const prior = await this.d.store.openItemRecord(existing);
+          const upgrade = prior !== null && prior.trust === "reference" && r.trust === "owner";
+          const refresh = r.refresh === true && prior !== null && prior.sourceRef !== void 0 && prior.sourceRef === r.sourceRef;
+          if (!upgrade && !refresh) return { ok: false, reason: "duplicate" };
+          if (refresh && !upgrade && r.noChunk === true && prior.text === r.text) return { ok: true, unchanged: true, itemIds: [existing.itemId], evicted: [], overCap: false };
+          replace = { firstItemId: existing.itemId, priorSealed: existing.sealedRecord };
+        }
+        const res = this.d.store.insertItems({
+          scopeKind: r.scopeKind,
+          scopeId: r.scopeId,
+          channelId: r.channelId,
+          kind: r.kind,
+          originId: r.originId,
+          originAt: r.originAt,
+          storedAt,
+          sourceRef: r.sourceRef ?? null,
+          parts,
+          expect: r.expect,
+          ...replace ? { replace } : {},
+          ...r.capExempt ? { capExempt: true } : {}
+        });
+        return res;
+      });
+    } catch {
+      return this.skip("store");
+    }
+    if (!out.ok) return this.skip(out.reason);
+    if ("unchanged" in out) return { ok: true, itemIds: [...out.itemIds] };
+    this.rankingNote(() => this.d.ranking.added(parts.filter((p) => p.sealedVec !== null).map((p) => p.itemId)));
+    this.rankingNote(() => this.d.ranking.removed([...out.evicted]));
+    if (out.overCap) void this.evictLoop();
+    (this.d.log ?? writeServiceLog2)("info", "memory.item_written", {
+      source: ServiceLogEnum.of(r.source, ["owner_typed", "owner_voice", "agent_reply", "owner_pin", "migrated_note", "migrated_recall", "imported_history", "room_member", "room_voice", "person", "file", "room_transcript"]),
+      chunks: parts.length
+    });
+    return { ok: true, itemIds: [...out.itemIds] };
+  }
+  /** A post-commit hot-set notification: a throw is logged (content-free) and swallowed, never turned into a write failure. */
+  rankingNote(f) {
+    try {
+      f();
+    } catch (e) {
+      (this.d.log ?? writeServiceLog2)("warn", "memory.ranking_notify_failed", {}, e);
+    }
+  }
+  /** H-7: batches of at most EVICT_BATCH_MAX rows, a yield between batches, one loop at a time. */
+  evictLoop() {
+    if (this.evicting) return this.evicting;
+    this.evicting = (async () => {
+      try {
+        for (; ; ) {
+          const r = await this.d.exclusive(async () => this.d.store.evictBatch());
+          this.rankingNote(() => this.d.ranking.removed(r.evicted));
+          if (!r.overCap || r.evicted.length === 0) return;
+          await new Promise((res) => setImmediate(res));
+        }
+      } catch (e) {
+        (this.d.log ?? writeServiceLog2)("warn", "memory.evict_failed", {}, e);
+      } finally {
+        this.evicting = null;
+      }
+    })();
+    return this.evicting;
+  }
+};
+
+// src/memory/unified/item-reembed.ts
+var ROWS_PER_TICK2 = 16;
+var EMBED_TIMEOUT_MS2 = 3e4;
+var LIST_DEADLINE_MS = 5e3;
+var ItemReembed = class {
+  constructor(d) {
+    this.d = d;
+  }
+  running = false;
+  async tick() {
+    if (this.running || !this.d.embedOn() || this.d.paused() || this.d.embedder.state().state !== "ready") return 0;
+    this.running = true;
+    try {
+      const rows = await this.d.ranking.pending(ROWS_PER_TICK2, Date.now() + LIST_DEADLINE_MS);
+      if (typeof rows === "string") return 0;
+      let done = 0;
+      for (const r of rows) {
+        if (this.d.paused()) break;
+        const capture = this.d.store.itemCapture(r.channelId);
+        let sealed;
+        try {
+          const vec = await this.d.embedder.embed(r.text, 1, { signal: AbortSignal.timeout(EMBED_TIMEOUT_MS2) });
+          if (vec.length !== 384) throw new Error("bad vector length");
+          sealed = await this.d.store.sealItemVec(r, this.d.modelId, vec);
+        } catch (e) {
+          (this.d.log ?? writeServiceLog2)("warn", "memory.reembed_failed", {}, e);
+          continue;
+        }
+        const ok = await this.d.exclusive(async () => this.d.store.updateItemVec(r.itemId, null, sealed, this.d.modelId, r.channelId, capture));
+        if (ok) {
+          this.d.ranking.added([r.itemId]);
+          done++;
+        }
+      }
+      return done;
+    } finally {
+      this.running = false;
+    }
+  }
+};
+
+// src/memory/unified/ranking-core-constants.ts
+var TYPED_ITEMS_MAX = 10;
+var VOICE_ITEMS_MAX = 3;
+var READ_CHARS_MAX = 6e3;
+var PINNED_CHARS_MAX = 4e3;
+
+// src/memory/unified/read-book.ts
+var FRAME_ITEMS_MAX = 210;
+var FRAME_TEXT_MAX = ITEM_LINE_MAX;
+function clampText(t) {
+  if (t.length <= FRAME_TEXT_MAX) return t;
+  const c = t.slice(0, FRAME_TEXT_MAX);
+  const last = c.charCodeAt(c.length - 1);
+  return last >= 55296 && last <= 56319 ? c.slice(0, -1) : c;
+}
+var same = (a, b) => a.clearGeneration === b.clearGeneration && a.roomClearGeneration === b.roomClearGeneration && a.enableEpoch === b.enableEpoch && a.purgeEpoch === b.purgeEpoch && a.contentEpoch === b.contentEpoch;
+var MAP_MAX = 256;
+var UnifiedReadBook = class {
+  constructor(d) {
+    this.d = d;
+  }
+  entries = /* @__PURE__ */ new Map();
+  pinCache = /* @__PURE__ */ new Map();
+  /**
+   * Plan audit M-6: the texts DELIVERED with each message, kept until ack/nack/retire (`drop`), so a forget that follows
+   * a pin in the same message (the pin's dropChannelLocked empties `entries`) still finds its text for the Forgot: line.
+   * Cleared by a clear (dropAllLocked) and an owner-scope purge (dropScopeLocked), never by a channel cache refresh.
+   */
+  shown = /* @__PURE__ */ new Map();
+  reads = 0;
+  /** Fix round 1: turns whose read missed its deadline (a local late, or a pins/query answer late or failed); one per turn. */
+  misses = 0;
+  /**
+   * Fix round 1 (ruling): bumped by every drop*Locked and by bumpGeneration (Task 28: a pin insert). Taken before the
+   * pins request and compared at install and before the entry is kept, so a drop during an await is never undone.
+   */
+  gen = 0;
+  /** Fix round 2: reads thrown away because the generation moved (a drop, a pin insert); not deadline misses. */
+  discarded = 0;
+  /** The health key memory_reads: owner-DM reads started since boot. */
+  readsAttempted() {
+    return this.reads;
+  }
+  /** The health key memory_deadline_misses: owner-DM turns that got no search result in time (U15). */
+  deadlineMisses() {
+    return this.misses;
+  }
+  /** The health key memory_reads_discarded: reads not kept because a drop or pin insert moved the generation during them. */
+  readsDiscarded() {
+    return this.discarded;
+  }
+  /** Invalidates the pin cache and every read in flight (Task 28 calls it, under the memory mutex, when a pin is inserted). */
+  bumpGeneration() {
+    this.gen++;
+    this.pinCache.clear();
+  }
+  async prepare(p) {
+    const capture = this.d.store.itemCapture(p.channelId);
+    const clock = this.d.now ?? Date.now;
+    const gen2 = this.gen;
+    this.entries.delete(p.messageId);
+    this.reads++;
+    let missed = false;
+    let spent = false;
+    const deadlineAt = clock() + (p.kind === "voice" ? RECALL_QUERY_TIMEOUT_VOICE_MS : RECALL_QUERY_TIMEOUT_TEXT_MS);
+    const current = () => this.gen === gen2 && same(this.d.store.itemCapture(p.channelId), capture);
+    let pins = this.pinCache.get(p.scopeId);
+    if (!pins || !same(pins.capture, capture)) {
+      pins = void 0;
+      const r2 = await this.d.ranking.pins(p.scopeId, PINNED_CHARS_MAX, deadlineAt);
+      if (typeof r2 === "string") missed = true;
+      else {
+        const fresh = { channelId: p.channelId, capture, pins: r2.pins, more: r2.more };
+        const install = this.d.exclusive(async () => {
+          if (current()) this.pinCache.set(p.scopeId, fresh);
+        });
+        install.catch(() => void 0);
+        let timer;
+        const won = await Promise.race([
+          install.then(() => "installed", () => "installed"),
+          new Promise((res) => {
+            timer = setTimeout(() => res("deadline"), Math.max(0, deadlineAt - clock()));
+          })
+        ]);
+        clearTimeout(timer);
+        if (won === "deadline") spent = true;
+        if (current()) pins = fresh;
+      }
+    }
+    let vec = null;
+    if (this.d.embedOn()) {
+      const preparing = this.d.embedder.state().state === "preparing";
+      if (this.d.embedder.state().state !== "ready") this.d.embedder.ensureStarted();
+      const waitStart = this.d.embedder.state().state;
+      const ready = spent ? false : await this.d.embedder.ready(Math.max(0, deadlineAt - clock())).catch(() => false);
+      if (!spent && (!ready && (preparing || waitStart === "preparing") || clock() >= deadlineAt)) spent = true;
+      if (ready && !spent) {
+        const ac = new AbortController();
+        const timer = setTimeout(() => {
+          spent = true;
+          ac.abort();
+        }, Math.max(0, deadlineAt - clock()));
+        vec = await this.d.embedder.embed(p.text, 0, { signal: ac.signal }).then((v) => v.length === 384 ? v : null, () => null);
+        clearTimeout(timer);
+      }
+    }
+    if (spent) missed = true;
+    const r = !spent && clock() < deadlineAt ? await this.d.ranking.query({
+      scopes: [p.scopeId],
+      ownerScope: p.scopeId,
+      vec,
+      macs: queryTokenMacs(this.d.indexKey, p.text),
+      historyConversation: p.channelId,
+      currentMessageId: p.messageId,
+      maxItems: p.kind === "voice" ? VOICE_ITEMS_MAX : TYPED_ITEMS_MAX,
+      maxChars: READ_CHARS_MAX,
+      nowMs: clock(),
+      excludeOriginIds: []
+    }, deadlineAt) : "late";
+    if (typeof r === "string") missed = true;
+    if (missed) this.misses++;
+    if (this.gen !== gen2) {
+      this.discarded++;
+      return;
+    }
+    const pinIds = new Set((pins?.pins ?? []).map((x) => x.itemId));
+    const items = typeof r === "string" ? [] : r.items.filter((i) => !pinIds.has(i.itemId));
+    if (!pins && items.length === 0) return;
+    if (this.entries.size >= MAP_MAX) this.entries.delete(this.entries.keys().next().value);
+    this.entries.set(p.messageId, { channelId: p.channelId, scopeId: p.scopeId, capture, pins: pins?.pins ?? [], pinnedMore: pins?.more ?? 0, items });
+  }
+  /** ws flush (synchronous): the entry's own channel and owner scope, its capture still current (H-4, U11). */
+  deliverable(messageId, channelId, scopeIdNow) {
+    const e = this.entries.get(messageId);
+    if (!e || e.channelId !== channelId || e.scopeId !== scopeIdNow) return void 0;
+    if (!same(e.capture, this.d.store.itemCapture(channelId))) {
+      this.entries.delete(messageId);
+      return void 0;
+    }
+    const at = (i) => ({ id: i.itemId, source: i.source, at: i.originAt, text: clampText(i.text) });
+    const all = [
+      ...e.pins.map((i) => ({ block: "pinned", ...at(i) })),
+      ...e.items.map((i) => ({ block: i.trust === "owner" ? "owner" : "reference", ...at(i) }))
+    ];
+    const items = all.slice(0, FRAME_ITEMS_MAX);
+    const pinsCut = Math.max(0, e.pins.length - FRAME_ITEMS_MAX);
+    if (this.shown.size >= MAP_MAX && !this.shown.has(messageId)) this.shown.delete(this.shown.keys().next().value);
+    this.shown.set(messageId, { scopeId: e.scopeId, texts: new Map(items.map((i) => [i.id, i.text])) });
+    return { items, pinnedMore: e.pinnedMore + pinsCut };
+  }
+  /** Section 7.4 step 3: texts of owner-trust TYPED items shown with this delivery (never owner_voice, never reference). */
+  coverageTexts(messageId, shown) {
+    const e = this.entries.get(messageId);
+    if (!e) return [];
+    return [...e.pins, ...e.items].filter((i) => shown.has(i.itemId) && i.trust === "owner" && COVERAGE_SOURCES.has(i.source)).map((i) => i.text);
+  }
+  /** M-6: what was DELIVERED with this message (kept until ack), not the prepare-time entry a cache refresh can drop. */
+  shownText(messageId, itemId) {
+    return this.shown.get(messageId)?.texts.get(itemId);
+  }
+  /** Task 29 fix round 1: a forgotten item's delivered text leaves the shown map at once (not only at ack). */
+  forgetShown(messageId, itemId) {
+    this.shown.get(messageId)?.texts.delete(itemId);
+  }
+  drop(messageId) {
+    this.entries.delete(messageId);
+    this.shown.delete(messageId);
+  }
+  dropAllLocked() {
+    this.gen++;
+    this.entries.clear();
+    this.pinCache.clear();
+    this.shown.clear();
+  }
+  dropChannelLocked(channelId) {
+    this.gen++;
+    for (const [k, e] of this.entries) if (e.channelId === channelId) this.entries.delete(k);
+    for (const [k, c] of this.pinCache) if (c.channelId === channelId) this.pinCache.delete(k);
+  }
+  dropScopeLocked(scopeId) {
+    this.gen++;
+    for (const [k, e] of this.entries) if (e.scopeId === scopeId) this.entries.delete(k);
+    for (const [k, v] of this.shown) if (v.scopeId === scopeId) this.shown.delete(k);
+    this.pinCache.delete(scopeId);
+  }
+};
+
+// src/memory/unified/migrate.ts
+var OLD_TABLES_PRESENT = true;
+var MIGRATION_BATCH = 100;
+var yieldNow = () => new Promise((r) => setImmediate(r));
+var SLICE_MS = 5;
+var STOPS = /* @__PURE__ */ new Set(["cleared", "room_cleared", "disabled", "purged"]);
+var TRANSIENT = /* @__PURE__ */ new Set(["store"]);
+async function migrateSource(d, source, c, read, cursorOf, write, timeOf, tally) {
+  const since = d.store.migrationMarker(source, c);
+  let cursor = null, newest = since;
+  let held = null;
+  let slice = performance.now();
+  const advance = () => {
+    const to = held === null ? newest : Math.min(newest, held);
+    if (to > since) d.store.setMigrationMarker(source, c, to);
+  };
+  const shutdown = () => {
+    advance();
+    return { stop: "shutdown" };
+  };
+  for (; ; ) {
+    if (d.stopping?.() === true) return shutdown();
+    const b = await read(since, cursor);
+    tally.unreadable += b.unreadable;
+    for (const r of b.rows) {
+      if (performance.now() - slice >= SLICE_MS) {
+        await yieldNow();
+        slice = performance.now();
+        if (d.stopping?.() === true) return shutdown();
+      }
+      const out = await write(r);
+      if (out === null) continue;
+      if (out.ok) tally.written++;
+      else if (STOPS.has(out.reason)) {
+        advance();
+        return { stop: out.reason };
+      } else if (TRANSIENT.has(out.reason)) {
+        const at = timeOf(r);
+        held = held === null ? at : Math.min(held, at);
+      }
+    }
+    if (!b.next) break;
+    cursor = cursorOf(b.next);
+    newest = Math.max(newest, b.next.at);
+    await yieldNow();
+    slice = performance.now();
+  }
+  advance();
+  return null;
+}
+async function runMigration(d, o = {}) {
+  const res = { notes: 0, recall: 0, history: 0, skipped: 0, excluded: 0, aborted: 0, unreadable: 0 };
+  const convs = o.only !== void 0 ? [o.only] : [.../* @__PURE__ */ new Set([...d.store.noteConversationIds(), ...d.store.recallConversationIds(), ...d.store.historyConversationIds()])].sort();
+  for (const c of convs) {
+    if (d.stopping?.() === true) {
+      res.aborted++;
+      break;
+    }
+    const cls = d.classify(c);
+    if (cls.kind === "excluded") {
+      res.excluded++;
+      continue;
+    }
+    if (cls.kind === "unknown") {
+      res.skipped++;
+      continue;
+    }
+    const scopeId = ownerDmScopeId(c, cls.ownerId);
+    const expect = d.store.itemCapture(c);
+    const t = { written: 0, unreadable: 0 };
+    const done = (k) => {
+      res[k] += t.written;
+      res.unreadable += t.unreadable;
+      t.written = 0;
+      t.unreadable = 0;
+    };
+    let stop = await migrateSource(
+      d,
+      "note",
+      c,
+      (since, after) => d.store.readNotesForMigration(c, since, after, MIGRATION_BATCH),
+      (n) => n,
+      (r) => d.items.commit({
+        scopeKind: "owner_dm",
+        scopeId,
+        channelId: c,
+        kind: "pinned",
+        originId: `note:${r.noteId}`,
+        originAt: r.createdAt,
+        source: "migrated_note",
+        trust: "owner",
+        text: stripInvisible(r.text),
+        sourceRef: noteSourceRef(c, r.noteId),
+        noChunk: true,
+        refresh: true,
+        capExempt: true,
+        pendingOnly: true,
+        expect
+      }),
+      (r) => r.updatedAt,
+      t
+    );
+    const pins = t.written;
+    done("notes");
+    if (pins > 0) await d.pinsChanged?.();
+    if (!stop) {
+      stop = await migrateSource(
+        d,
+        "recall",
+        c,
+        (since, after) => d.store.readRecallForMigration(c, since, after, MIGRATION_BATCH),
+        (n) => n,
+        async (r) => d.store.recallTombstoned(c, r.messageId) ? null : d.items.commit({
+          scopeKind: "owner_dm",
+          scopeId,
+          channelId: c,
+          kind: "auto",
+          originId: r.messageId,
+          originAt: r.sentAt,
+          source: "migrated_recall",
+          trust: "owner",
+          text: r.text,
+          sourceRef: recallSourceRef(c, r.messageId),
+          vec: r.vec,
+          vecModelId: r.modelId,
+          pendingOnly: true,
+          expect
+        }),
+        (r) => r.indexedAt,
+        t
+      );
+      done("recall");
+    }
+    if (!stop) {
+      stop = await migrateSource(
+        d,
+        "history",
+        c,
+        (since, afterSeq) => d.store.readHistoryForMigration(c, since, afterSeq ?? 0, MIGRATION_BATCH),
+        (n) => n.id,
+        async (r) => r.messageId && d.store.recallTombstoned(c, r.messageId) ? null : d.items.commit({
+          scopeKind: "owner_dm",
+          scopeId,
+          channelId: c,
+          kind: "auto",
+          originId: r.messageId ?? `seq:${r.seq}`,
+          originAt: r.recordedAt,
+          source: "imported_history",
+          trust: "reference",
+          text: r.text,
+          sourceRef: historySourceRef(c, r.seq),
+          pendingOnly: true,
+          expect
+        }),
+        (r) => r.recordedAt,
+        t
+      );
+      done("history");
+    }
+    if (stop) {
+      res.aborted++;
+      if (stop.stop === "cleared" || stop.stop === "room_cleared") {
+        const at = Date.now();
+        for (const s of ["note", "recall"]) d.store.setMigrationMarker(s, c, at);
+      }
+    }
+  }
+  (d.log ?? writeServiceLog2)("info", "memory.migration_ran", { ...res });
+  return res;
+}
+function reupgradeReconcile(store) {
+  return store.reupgradeReconcileUnified(OLD_TABLES_PRESENT);
+}
+
 // src/memory/note-frames.ts
 var REQUEST_ID_MAX = 64;
 var MESSAGE_ID_MAX = 200;
-var FRAME_TEXT_MAX = 4e3;
+var FRAME_TEXT_MAX2 = 4e3;
 var okId = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 1;
 var RECALL_ID = /^r([1-9][0-9]{0,15})$/;
 function parseMemoryNoteFrame(m) {
   const rid = m.request_id, mid = m.message_id, op = m.op, id = m.id, text = m.text;
   if (typeof rid !== "string" || rid.length < 1 || rid.length > REQUEST_ID_MAX) return null;
   if (typeof mid !== "string" || mid.length < 1 || mid.length > MESSAGE_ID_MAX) return null;
-  const hasText = typeof text === "string" && text.length > 0 && text.length <= FRAME_TEXT_MAX;
+  const hasText = typeof text === "string" && text.length > 0 && text.length <= FRAME_TEXT_MAX2;
   if (op === "add") return id === void 0 && hasText ? { request_id: rid, message_id: mid, op, text } : null;
   if (op === "replace") return okId(id) && hasText ? { request_id: rid, message_id: mid, op, id, text } : null;
   if (op === "forget") {
@@ -31372,9 +33358,9 @@ var VaultPinMismatchError = class extends VaultIntegrityError {
 };
 var VAULT_PINS_TOGETHER = "expected_content_hash and expected_dek_commit go together";
 async function vaultWriteImpl(args2) {
-  const gen = args2.deps.currentGeneration;
-  const kek = args2.deps.exporterKekForGeneration(gen);
-  const aad = buildNodeAad(args2.nodeId, args2.enclaveId, gen);
+  const gen2 = args2.deps.currentGeneration;
+  const kek = args2.deps.exporterKekForGeneration(gen2);
+  const aad = buildNodeAad(args2.nodeId, args2.enclaveId, gen2);
   const { encryptedData, fileKey, fileNonce, digest } = await encryptFile(args2.bytes);
   const wrapped = wrapDek(packDekMaterial(fileKey, fileNonce), kek, aad);
   const body = {
@@ -31382,9 +33368,9 @@ async function vaultWriteImpl(args2) {
     kind: "file",
     parent_id: null,
     enc_name_b64: bytesToBase642(sealName(args2.name, kek, aad)),
-    name_kek_generation: gen,
+    name_kek_generation: gen2,
     wrapped_dek_b64: bytesToBase642(wrapped),
-    kek_generation: gen,
+    kek_generation: gen2,
     content_hash: `blake2b:${digest}`
     // digest returned by encryptFile (over ciphertext)
   };
@@ -31412,9 +33398,9 @@ async function vaultReadImpl(args2) {
   }
   const wrap = [...meta.wraps].sort((a, b) => b.kek_generation - a.kek_generation)[0];
   if (!wrap) throw new VaultIntegrityError("vault: node has no DEK wrap");
-  const gen = wrap.kek_generation;
-  const kek = args2.deps.exporterKekForGeneration(gen);
-  const aad = buildNodeAad(args2.nodeId, args2.enclaveId, gen);
+  const gen2 = wrap.kek_generation;
+  const kek = args2.deps.exporterKekForGeneration(gen2);
+  const aad = buildNodeAad(args2.nodeId, args2.enclaveId, gen2);
   let fileKey, fileNonce;
   try {
     ({ fileKey, fileNonce } = unpackDekMaterial(unwrapDek(base64ToBytes2(wrap.wrapped_dek_b64), kek, aad)));
@@ -31553,7 +33539,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { basename as basename4, isAbsolute, join as join14 } from "node:path";
+import { basename as basename4, isAbsolute, join as join15 } from "node:path";
 var MEMORY_FILE = "MEMORY.md";
 var REAL_FS = {
   mkdir: (p, mode) => mkdirSync5(p, { recursive: true, mode }),
@@ -31564,7 +33550,7 @@ var REAL_FS = {
   unlink: (p) => unlinkSync(p)
 };
 function runtimeConfigDir(home, identityId) {
-  return join14(home, ".securecoms", "runtime-config", identityId);
+  return join15(home, ".securecoms", "runtime-config", identityId);
 }
 function assertManagedName(name) {
   if (!name || name.includes("/") || name.includes("\\") || name === "." || name === ".." || name !== basename4(name)) {
@@ -31595,13 +33581,13 @@ function atomicWrite(path, body, deps) {
 function writeManagedFiles(home, identityId, files, deps = REAL_FS) {
   const entries = Object.entries(files);
   for (const [name] of entries) assertManagedName(name);
-  const parent3 = join14(home, ".securecoms", "runtime-config");
+  const parent3 = join15(home, ".securecoms", "runtime-config");
   const dir = runtimeConfigDir(home, identityId);
-  for (const d of [join14(home, ".securecoms"), parent3, dir]) {
+  for (const d of [join15(home, ".securecoms"), parent3, dir]) {
     deps.mkdir(d, 448);
     deps.chmod(d, 448);
   }
-  for (const [name, body] of entries) atomicWrite(join14(dir, name), body, deps);
+  for (const [name, body] of entries) atomicWrite(join15(dir, name), body, deps);
 }
 function checkConfiguredPaths(skillsJson, statFn = (p) => {
   const s = statSync3(p);
@@ -31704,7 +33690,7 @@ function localLegacySources(doc) {
   return out;
 }
 function readLocalReport(home, identityId) {
-  const p = join14(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
+  const p = join15(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
   if (!existsSync4(p)) return null;
   let doc;
   try {
@@ -31729,7 +33715,7 @@ function readLocalReport(home, identityId) {
 }
 function deleteLegacyMemorySources(home, identityId, ids) {
   if (ids.length === 0) return 0;
-  const p = join14(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
+  const p = join15(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
   if (!existsSync4(p)) return 0;
   let doc;
   try {
@@ -31772,7 +33758,7 @@ async function applyLegacyMemoryFactDecisions(home, identityId, rawDecisions, re
     group.set(decision.fact_hash, decision);
     bySource.set(decision.source_id, group);
   }
-  const reportPath = join14(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
+  const reportPath = join15(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
   if (!existsSync4(reportPath)) return { sourcesDeleted: 0, factsAssigned: 0 };
   let doc;
   try {
@@ -31809,7 +33795,7 @@ async function applyLegacyMemoryFactDecisions(home, identityId, rawDecisions, re
   return { sourcesDeleted, factsAssigned };
 }
 function readManagedMemory(home, identityId) {
-  const p = join14(runtimeConfigDir(home, identityId), MEMORY_FILE);
+  const p = join15(runtimeConfigDir(home, identityId), MEMORY_FILE);
   if (!existsSync4(p)) return null;
   try {
     const body = readFileSync8(p, "utf8").trim();
@@ -31820,7 +33806,7 @@ function readManagedMemory(home, identityId) {
 }
 function pruneManagedMemory(home, identityId, hashes, deps = REAL_FS) {
   const dir = runtimeConfigDir(home, identityId);
-  const path = join14(dir, MEMORY_FILE);
+  const path = join15(dir, MEMORY_FILE);
   if (!existsSync4(path)) return 0;
   const drop = new Set(hashes);
   const before = deps.readFile(path).split("\n");
@@ -32050,6 +34036,9 @@ function voiceCoalesceWindowFromEnv(env = process.env) {
   if (raw === void 0 || !/^\d{1,6}$/.test(raw.trim())) return VOICE_COALESCE_WINDOW_MS;
   return Math.min(Number(raw.trim()), VOICE_COALESCE_WINDOW_MAX_MS);
 }
+function voiceWindowEligible(t) {
+  return t.voiceMode === true && t.speaker !== void 0 && t.transcribed === true && t.voiceGuidance !== void 0 && !t.isCallStart;
+}
 function waitMs(ms) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve) => {
@@ -32255,6 +34244,7 @@ var BootDrainRotationRefusedError = class extends Error {
     this.name = "BootDrainRotationRefusedError";
   }
 };
+var OWNER_VOICE_TRUST = "owner";
 var BridgeAgent = class _BridgeAgent {
   constructor(cfg, deps = {}) {
     this.cfg = cfg;
@@ -32352,6 +34342,21 @@ var BridgeAgent = class _BridgeAgent {
     this.home = deps.home ?? homedir4();
     this.platform = deps.platform ?? process.platform;
     this.machinePaths = deps.hostMachine === true || deps.home !== void 0;
+    this.unifiedOn = unifiedPart1On(deps.unifiedMemoryPart1);
+    this.indexKey = deriveMemoryIndexKey(seed);
+    this.ranking = new RankingClient({
+      spawn: () => {
+        const init = {
+          dbPath: cfg.storePath,
+          identityId: cfg.identityId,
+          storeKey: deriveMlsStoreKey(seed),
+          modelId: EMBEDDING_MANIFEST.modelId,
+          threshold: EMBEDDING_MANIFEST.similarityThreshold,
+          warm: windowsSemanticOn(this.platform)
+        };
+        return deps.rankingTransport ? deps.rankingTransport(init) : workerTransport(init, dirname4(fileURLToPath2(import.meta.url)));
+      }
+    });
     this.embedder = deps.embedder ?? (deps.hostMachine === true && deps.home === void 0 ? new EmbedderClient({ identityId: cfg.identityId, home: homedir4(), source: cfg.modelSource, fetchImpl: this.fetchImpl, platform: this.platform }) : INERT_EMBEDDER);
     this.recall = new RecallBook({
       store: this.store,
@@ -32360,7 +34365,7 @@ var BridgeAgent = class _BridgeAgent {
       modelId: EMBEDDING_MANIFEST.modelId,
       threshold: EMBEDDING_MANIFEST.similarityThreshold
     });
-    this.heartbeat = new CallHeartbeat(this.machinePaths ? join15(this.home, ".securecoms", "run", "voice-call") : null, cfg.identityId, VOICE_LIVE_WINDOW_MS);
+    this.heartbeat = new CallHeartbeat(this.machinePaths ? join16(this.home, ".securecoms", "run", "voice-call") : null, cfg.identityId, VOICE_LIVE_WINDOW_MS);
     this.reembed = new ReembedQueue({
       store: this.store,
       embedder: this.embedder,
@@ -32369,6 +34374,35 @@ var BridgeAgent = class _BridgeAgent {
       paused: () => this.heartbeat.anyLive(HEARTBEAT_STALE_MS),
       onEmbeddedLocked: (c, row, vec) => this.recall.onReembeddedLocked(c, row, vec)
     });
+    this.items = new ItemBook({
+      store: this.store,
+      embedder: this.embedder,
+      modelId: EMBEDDING_MANIFEST.modelId,
+      indexKey: this.indexKey,
+      exclusive: (fn) => this.notes.exclusive(fn),
+      ranking: this.ranking,
+      embedOn: () => windowsSemanticOn(this.platform),
+      paused: () => this.heartbeat.anyLive(HEARTBEAT_STALE_MS)
+    });
+    if (this.unifiedOn) {
+      this.unifiedReads = new UnifiedReadBook({
+        store: this.store,
+        ranking: this.ranking,
+        embedder: this.embedder,
+        embedOn: () => windowsSemanticOn(this.platform),
+        indexKey: this.indexKey,
+        exclusive: (fn) => this.notes.exclusive(fn)
+      });
+    }
+    this.itemReembed = new ItemReembed({
+      ranking: this.ranking,
+      store: this.store,
+      embedder: this.embedder,
+      exclusive: (fn) => this.notes.exclusive(fn),
+      modelId: EMBEDDING_MANIFEST.modelId,
+      paused: () => this.heartbeat.anyLive(HEARTBEAT_STALE_MS),
+      embedOn: () => windowsSemanticOn(this.platform)
+    });
     this.injectedFastLlm = !!deps.fastLlm;
     this.fileVoiceConfig = cfg.voice;
     this.fastLlm = deps.fastLlm ?? (cfg.voice?.fastPath.enabled ? new FastLlmClient(cfg.voice.fastPath, this.fetchImpl) : void 0);
@@ -32413,8 +34447,8 @@ var BridgeAgent = class _BridgeAgent {
       const j = await res.json();
       return String(j.attachment_id);
     };
-    this.attachmentsDirImpl = deps.attachmentsDir ?? join15(dirname4(cfg.storePath), "attachments");
-    this.vaultOwnerStoreImpl = deps.vaultOwnerStore ?? new FileOwnerAuthorityStore(join15(dirname4(cfg.storePath), "vault-owner-pins.json"));
+    this.attachmentsDirImpl = deps.attachmentsDir ?? join16(dirname4(cfg.storePath), "attachments");
+    this.vaultOwnerStoreImpl = deps.vaultOwnerStore ?? new FileOwnerAuthorityStore(join16(dirname4(cfg.storePath), "vault-owner-pins.json"));
     this.action = {
       begin: (channelId) => this.actionBegin(channelId),
       start: (opts) => this.actionStart(opts),
@@ -32878,6 +34912,20 @@ var BridgeAgent = class _BridgeAgent {
   embedder;
   /** 7b Task 16: the recall index (the single writer, I8: reached only from tapRecall). */
   recall;
+  unifiedOn;
+  /** Unified memory (plan Task 21, spec section 11.5): the token-MAC index key, derived from the identity seed. */
+  indexKey;
+  /** Unified memory (plan Task 21, U15): the ranking worker's client. Lazy: no worker starts until the first request. */
+  ranking;
+  /** Unified memory (plan Task 23, U9): the single writer. Every item write is a named call site of `this.items.commit`. */
+  items;
+  /** Unified memory (plan Task 26, C14): background embeds of pending items. Built in the constructor, after `this.ranking` exists. */
+  itemReembed;
+  itemReembedHot = false;
+  /** Unified memory (plan Task 27, spec section 8.1): the per-turn owner-DM read. Built only with the part 1 switch on. */
+  unifiedReads;
+  /** Plan Task 27: a runtime socket with no harness claim declared memory_unified. */
+  unifiedConsumerSeen = false;
   /** 7b Task 19 (spec §8, H1, ruling P-1): this identity's call heartbeat, and every identity's for the pause. */
   heartbeat;
   /** 7b Task 19 (spec §8): lazy re-embed of pending rows (never an insert; I8 untouched). */
@@ -32907,6 +34955,12 @@ 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();
+  /** Unified memory (plan Task 23): in-flight fire-and-forget item writes; close() and tests wait for them (bounded). */
+  unifiedWork = /* @__PURE__ */ new Set();
+  /** Unified memory (plan Task 30, OQ-P1): conversations whose migration this process has started (or finished). */
+  migrationStarted = /* @__PURE__ */ new Set();
+  /** Unified memory (plan Task 23, the 7b M1/H-1 rule): turns restored at boot or drained before the boot config settled. */
+  deferredUnifiedIds = /* @__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.
@@ -32914,14 +34968,26 @@ 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
    * conversation per process, not once per inbound message. Bounded: cleared when it reaches 4096 entries.
    */
   recallAudienceLogged = /* @__PURE__ */ new Set();
+  /** Plan Task 23 fix round 1: the unified tap's `audience` skip, logged once per conversation per process (the recallAudienceLogged rule). */
+  unifiedAudienceLogged = /* @__PURE__ */ new Set();
   /** Off until a payload arrives (spec §5.3: before the first payload of a process, recall neither indexes nor reads nor purges). */
   recallConfig = { on: false };
+  /** Unified memory (U14, R-U20): the parsed payload's switch; off until a payload arrives. */
+  unifiedConfig = { on: false };
+  /** Unified memory (U14): the store's unified_enabled as last committed by applyUnifiedPayload; false on any failure. */
+  unifiedEnabledMirror = false;
   /** The membership sweep now running, if any; close() waits for it (bounded). */
   membershipSweepWork = null;
   /** Task 13 fix round LOW 3: when each channel last delivered an inbound row to this process. */
@@ -32946,6 +35012,27 @@ var BridgeAgent = class _BridgeAgent {
     lastInboundAt: (c) => this.lastInboundAt.get(c),
     stopping: () => this.closingDown
   });
+  /**
+   * Unified memory (plan Task 22, spec section 8.2; H-4, H-A, CR-1): freeze and purge of an owner-DM scope on owner change.
+   * Roster facts only (OQ-P3); the persisted is_dm, never a stale in-memory one (controller ruling C8). The absence record
+   * reuses agent_memory_conversation keyed by the scope id: it holds a NUL, a channel id never does, so the keys cannot
+   * collide, and memoryConversationIds reads the content tables only, so the membership sweep never sees it.
+   */
+  ownerScopes = new OwnerScopeSweeper({
+    scopes: () => [...this.store.ownerDmScopeIds(), ...this.store.dmOwnerScopes()],
+    factsOf: (c) => ({ ...this.ownerFacts(c), isDm: this.store.getChannelMeta(c)?.isDm }),
+    // Final review store I-2 (bridge half): an owner change on a DM with no items still freezes its migration markers.
+    oldTableChannels: () => [.../* @__PURE__ */ new Set([...this.store.noteConversationIds(), ...this.store.recallConversationIds(), ...this.store.historyConversationIds()])],
+    recordOwner: (c, o) => {
+      this.store.recordDmOwner(c, o);
+    },
+    absenceOf: (s) => this.store.conversationAbsence(s),
+    markAbsent: (s, n) => this.store.markConversationAbsent(s, n),
+    clearAbsence: (s) => this.store.clearConversationAbsence(s),
+    purge: (s) => this.purgeOwnerScope(s),
+    now: () => Date.now(),
+    stopping: () => this.closingDown
+  });
   listeners = /* @__PURE__ */ new Set();
   startedAt = 0;
   store;
@@ -33200,6 +35287,10 @@ var BridgeAgent = class _BridgeAgent {
         // the generation is the store's applied value, never the payload's.
         // Final review I-1: and only once a notes-reading runtime said hello.
         memory_notes: this.notesProviderOn() && this.notesConsumerSeen,
+        // Unified memory (plan Task 31): only while the compiled part 1 switch is on, so a
+        // 0.28-equivalent bridge never makes the web show the unified panel. Numbers and
+        // booleans only (U1).
+        ...this.reportedUnified(),
         ...this.reportedClearGeneration(),
         // 7b spec §9.2 (Task 19): capability versus state. Read-only: the report never starts the embedder.
         ...this.reportedRecall(),
@@ -33262,6 +35353,13 @@ var BridgeAgent = class _BridgeAgent {
     } catch (e) {
       writeServiceLog2("warn", "memory.recall_boot_reconcile_failed", {}, e);
     }
+    if (this.unifiedOn) {
+      try {
+        reupgradeReconcile(this.store);
+      } catch (e) {
+        writeServiceLog2("warn", "memory.unified_boot_reconcile_failed", {}, e);
+      }
+    }
     this.bootDrainPending = true;
     const drain = this.ingestOnce().then(() => true, () => true);
     const drainedInTime = await Promise.race([
@@ -33299,13 +35397,14 @@ var BridgeAgent = class _BridgeAgent {
     }
     await this.warmRestoredNotes();
     await this.reindexRestoredTurns();
+    if (this.unifiedOn) await this.reindexUnifiedRestored();
     this.runtimeConfigTimer = setInterval(() => {
       void this.refetchRuntimeConfig();
     }, 6 * 60 * 60 * 1e3);
     this.runtimeConfigTimer.unref?.();
     this.membershipSweepTimer = setInterval(() => {
       if (this.closingDown || this.membershipSweepWork) return;
-      this.membershipSweepWork = this.membershipSweeper.sweep().then(() => void 0, (e) => writeServiceLog2("error", "memory.purge_sweep_failed", {}, e)).finally(() => {
+      this.membershipSweepWork = this.runMembershipSweeps().finally(() => {
         this.membershipSweepWork = null;
       });
     }, PURGE_SWEEP_INTERVAL_MS);
@@ -34224,8 +36323,9 @@ var BridgeAgent = class _BridgeAgent {
     if (this.isIdempotentSend(messageId, opts)) return this.trackReplyWork(this.sendIdempotent(channelId, body, opts));
     const id = resolveMessageId(messageId);
     const purgeEpochBeforePublish = this.store.conversationPurgeEpoch(channelId);
+    const replyCapture = this.unifiedReplyCapture(channelId, opts.inReplyTo);
     await this.publishBody(channelId, body, id);
-    this.afterPublish(channelId, body, id, opts, purgeEpochBeforePublish);
+    this.afterPublish(channelId, body, id, opts, purgeEpochBeforePublish, replyCapture);
     return { message_id: id, status: "sent" };
   }
   /** PR #716 review MEDIUM-5: register reply work so close() can wait for it. */
@@ -34242,8 +36342,9 @@ var BridgeAgent = class _BridgeAgent {
     if (this.isIdempotentSend(messageId, opts)) return this.trackReplyWork(this.sendIdempotent(channelId, body, opts));
     const id = resolveMessageId(messageId);
     const purgeEpochBeforePublish = this.store.conversationPurgeEpoch(channelId);
+    const replyCapture = this.unifiedReplyCapture(channelId, opts.inReplyTo);
     await this.publishBody(channelId, body, id);
-    this.afterPublish(channelId, body, id, opts, purgeEpochBeforePublish);
+    this.afterPublish(channelId, body, id, opts, purgeEpochBeforePublish, replyCapture);
     return { message_id: id, status: "sent" };
   }
   /**
@@ -34375,10 +36476,51 @@ var BridgeAgent = class _BridgeAgent {
     if (meta && !meta.is_dm) this.enforceRateFloor("room", channelId);
   }
   /** Bookkeeping after a CONFIRMED publish of `body` under `id`. */
-  afterPublish(channelId, body, id, opts, purgeEpoch) {
+  afterPublish(channelId, body, id, opts, purgeEpoch, replyCapture) {
     if (opts.agentTurn !== false) this.agentHops.noteOwnSend(channelId);
     const modality = this.spokenReplyIds.has(id) ? "voice" : "text";
-    if (body.kind === "text") void recordOutboundMemory(this.memory, channelId, body.text, id, modality, purgeEpoch);
+    const bridgeLine = this.unifiedOn && body.kind === "text" && isBridgeMemoryLine(body.text);
+    if (body.kind === "text" && !bridgeLine) void recordOutboundMemory(this.memory, channelId, body.text, id, modality, purgeEpoch);
+    if (this.unifiedOn && body.kind === "text" && !bridgeLine) this.spawnUnifiedReply(channelId, body.text, id, replyCapture ?? null);
+  }
+  /**
+   * Final review bridge I-1 (ledger T25): the agent reply's U11 capture, taken BEFORE the publish await. The clear generation
+   * is the reply turn's ingest stamp (the in-reply-to message's), so a Clear all applied while the model generated the
+   * reply refuses it `cleared`; the enable epoch, room-clear generation and purge epoch are read here, before the publish.
+   * No in-reply-to, or no stamp held for it: null, and the reply is not remembered (fail closed). Switch off: null, no read.
+   */
+  unifiedReplyCapture(channelId, inReplyTo) {
+    if (!this.unifiedOn || inReplyTo === void 0) return null;
+    const stamp = this.ingestGeneration.get(inReplyTo);
+    if (stamp === void 0) return null;
+    return { ...this.store.itemCapture(channelId), clearGeneration: stamp };
+  }
+  /** Section 7.1 agent reply, section 24.2: the owner-DM predicate for the channel at write (no sender), else nothing. Reference trust always (U18). OQ-P2: bridge-authored Pinned:/Forgot: lines are filtered by the caller. */
+  spawnUnifiedReply(channelId, text, messageId, expect) {
+    if (expect === null) return;
+    const work = (async () => {
+      try {
+        if (!this.unifiedProviderOn()) return;
+        const scopeId = await this.ownerScopeForWrite(channelId);
+        if (scopeId === null) return;
+        await this.items.commit({
+          scopeKind: "owner_dm",
+          scopeId,
+          channelId,
+          kind: "auto",
+          originId: messageId,
+          originAt: Date.now(),
+          source: "agent_reply",
+          trust: "reference",
+          text,
+          expect
+        });
+      } catch {
+        writeServiceLog2("warn", "memory.unified_reply_failed", {});
+      }
+    })();
+    this.unifiedWork.add(work);
+    void work.finally(() => this.unifiedWork.delete(work));
   }
   isIdempotentSend(messageId, opts) {
     if (opts.inReplyTo === void 0 && opts.idempotencyKey === void 0) return false;
@@ -34491,6 +36633,7 @@ var BridgeAgent = class _BridgeAgent {
       const bytes = intent.body;
       const body = decodeReplyBody(bytes);
       const purgeEpochBeforePublish = this.store.conversationPurgeEpoch(intent.channelId);
+      const replyCapture = this.unifiedReplyCapture(intent.channelId, intent.inReplyTo ?? void 0);
       try {
         await this.publishIntentWithRetry(intent.channelId, body, intent.replyMessageId, key, intent.inReplyTo);
       } catch (e) {
@@ -34524,7 +36667,7 @@ var BridgeAgent = class _BridgeAgent {
         throw e;
       }
       this.store.markReplyIntentSent(key.scope, key.part);
-      this.afterPublish(intent.channelId, body, intent.replyMessageId, opts, purgeEpochBeforePublish);
+      this.afterPublish(intent.channelId, body, intent.replyMessageId, opts, purgeEpochBeforePublish, replyCapture);
       return { message_id: intent.replyMessageId, status: "sent" };
     });
   }
@@ -34806,7 +36949,9 @@ var BridgeAgent = class _BridgeAgent {
   }
   /** §5.4: one conversation's turns, facts, notes and recall, inside the memory mutex, with every in-memory copy. */
   async purgeConversation(channelId) {
+    const scopes = this.unifiedOn ? this.store.ownerDmScopeIds().filter((s) => parseOwnerDmScopeId(s)?.channelId === channelId) : [];
     await this.notes.purgeChannel(channelId);
+    for (const s of scopes) this.store.clearConversationAbsence(s);
     await this.onConversationPurged(channelId);
   }
   /**
@@ -34817,7 +36962,57 @@ var BridgeAgent = class _BridgeAgent {
    */
   async onConversationPurged(channelId) {
     this.lastInboundAt.delete(channelId);
-    await this.notes.exclusive(async () => this.recall.dropConversationLocked(channelId));
+    await this.notes.exclusive(async () => {
+      this.recall.dropConversationLocked(channelId);
+      if (this.unifiedOn) this.unifiedReads?.dropChannelLocked(channelId);
+    });
+    if (this.unifiedOn) this.rankingNote(() => this.ranking.reset());
+  }
+  /**
+   * The hourly sweeps (spec section 5.4; plan Task 22): the membership sweep, then, with unified memory compiled on, the
+   * owner-DM scope sweep. Each failure is logged content-free; neither escapes. Controller ruling (Task 22 fix round 1):
+   * the owner sweep is NOT gated on memory being on: "off does not purge" protects the owner's own memory from the switch;
+   * an owner change is a security event and purges whatever the mode.
+   */
+  async runMembershipSweeps() {
+    await this.membershipSweeper.sweep().then(() => void 0, (e) => writeServiceLog2("error", "memory.purge_sweep_failed", {}, e));
+    if (!this.unifiedOn || this.closingDown) return;
+    await this.ownerScopes.sweep().then(() => void 0, (e) => writeServiceLog2("error", "memory.owner_scope_sweep_failed", {}, e));
+  }
+  /** Plan Task 22: one frozen owner-DM scope, pins included, with its read entries; the ranking worker reloads. */
+  async purgeOwnerScope(scopeId) {
+    await this.notes.exclusive(async () => {
+      this.store.purgeScope(scopeId);
+      this.unifiedReads?.dropScopeLocked(scopeId);
+    });
+    this.rankingNote(() => this.ranking.reset());
+  }
+  /** Final review bridge I-2(c): a hot-set notification after a committed store change; a throw is logged, never escapes. */
+  rankingNote(f) {
+    try {
+      f();
+    } catch (e) {
+      writeServiceLog2("warn", "memory.ranking_notify_failed", {}, e);
+    }
+  }
+  /** H-4 facts for one channel, from the caches only (no network). */
+  ownerFacts(channelId) {
+    const entry = this.freshRosterEntry(channelId);
+    const pin = this.channelOwner.get(channelId);
+    const member = pin && pin !== "anomalous" ? entry?.members.get(pin.identityId) : void 0;
+    return { isDm: this.freshMeta(channelId)?.is_dm, pin, member, rosterKnown: entry !== void 0 };
+  }
+  /** The owner-DM scope id now, or null (unknown counts as null: fail closed for reads and writes). */
+  ownerScopeNow(channelId) {
+    if (!this.ownerDmDefaultGrants) return null;
+    const s = ownerScopeFrom(channelId, this.ownerFacts(channelId));
+    return s === "unknown" ? null : s;
+  }
+  /** Section 24.2: the agent-reply writer's predicate: the scope now, and the roster fresh at the held MLS position or DM cycle-fresh. */
+  async ownerScopeForWrite(channelId) {
+    const held = await this.heldPosition(channelId);
+    const fresh = rosterFreshAt(this.freshRosterEntry(channelId), held.epoch, held.groupId) || this.ownerDmCycleFresh.has(channelId);
+    return fresh ? this.ownerScopeNow(channelId) : null;
   }
   /** M6 (Task 11): idempotent get-or-create resolve of the enclave's hidden
    *  vault channel id — used as the fallback when a caller omits
@@ -34939,12 +37134,12 @@ var BridgeAgent = class _BridgeAgent {
     }
     this.vaultLastSeenGeneration.set(enclaveId, opened.header.generation);
     const gens = /* @__PURE__ */ new Map();
-    opened.generations.forEach((kek, gen) => gens.set(gen, kek));
+    opened.generations.forEach((kek, gen2) => gens.set(gen2, kek));
     return {
       currentGeneration: opened.header.generation,
-      kekForGeneration: (gen) => {
-        const kek = gens.get(gen);
-        if (!kek) throw new VaultIntegrityError(`vault: no KEK cached for generation ${gen}`);
+      kekForGeneration: (gen2) => {
+        const kek = gens.get(gen2);
+        if (!kek) throw new VaultIntegrityError(`vault: no KEK cached for generation ${gen2}`);
         return kek;
       }
     };
@@ -35078,6 +37273,7 @@ var BridgeAgent = class _BridgeAgent {
    * this point keeps the last applied state.
    */
   async applyPayloadMemory(raw) {
+    if (this.unifiedOn) return this.applyUnifiedPayload(raw);
     const mem = parsePayloadMemory(raw);
     this.memoryConfigConfirmed = true;
     if (!mem.notesOn) {
@@ -35106,6 +37302,95 @@ var BridgeAgent = class _BridgeAgent {
     this.memoryConfig = { notesOn: true };
     await this.applyRecallModeFromPayload(mem);
   }
+  /**
+   * Spec section 13 (R-U20, M-7, U14). Deletions first, whatever the mode; then the switch. Never throws.
+   * Fix round 1 (controller ruling, U14 fail closed, 7a M-2 precedent): a clear that throws while the payload is above
+   * the applied generation (or a room clear above that room's) holds unified memory OFF until a later refetch applies it.
+   */
+  async applyUnifiedPayload(raw) {
+    const p = parseUnifiedPayloadMemory(raw);
+    this.memoryConfigConfirmed = true;
+    let clearPending = false;
+    try {
+      if (p.clearGeneration !== void 0) {
+        let applied = false;
+        await this.notes.exclusive(async () => {
+          applied = this.store.applyUnifiedClear(p.clearGeneration);
+          if (applied) this.unifiedReads?.dropAllLocked();
+        });
+        if (applied) this.rankingNote(() => this.ranking.reset());
+        await this.notes.clear(p.clearGeneration);
+      }
+      for (const [channelId, g] of p.roomClears) {
+        let applied = false;
+        await this.notes.exclusive(async () => {
+          applied = this.store.applyRoomClear(channelId, g);
+          if (applied) this.unifiedReads?.dropChannelLocked(channelId);
+        });
+        if (applied) this.rankingNote(() => this.ranking.reset());
+      }
+    } catch (e) {
+      writeServiceLog2("warn", "memory.unified_clear_failed", {}, e);
+      clearPending = this.unifiedClearPending(p);
+    }
+    const reason = !p.on ? p.reason ?? "unrecognized" : this.cfg.memoryEnabled === false ? "local" : clearPending ? "clear_pending" : null;
+    const on = reason === null;
+    this.unifiedConfig = { on };
+    this.memoryConfig = { notesOn: on };
+    this.recallConfig = { on: false };
+    try {
+      await this.notes.exclusive(async () => {
+        this.store.setUnifiedEnabled(on);
+      });
+      this.unifiedEnabledMirror = on;
+    } catch (e) {
+      this.unifiedEnabledMirror = false;
+      writeServiceLog2("warn", "memory.unified_switch_failed", {}, e);
+    }
+    if (reason !== null) writeServiceLog2("info", "memory.unified_off", { reason_class: ServiceLogEnum.of(reason, ["off", "unrecognized", "local", "clear_pending"]) });
+  }
+  /** Fix round 1: after a clear threw, is the payload still above what the store applied? An unreadable store is pending (fail closed). */
+  unifiedClearPending(p) {
+    try {
+      if (p.clearGeneration !== void 0 && p.clearGeneration > this.store.itemCapture("").clearGeneration) return true;
+      for (const [channelId, g] of p.roomClears) if (g > this.store.itemCapture(channelId).roomClearGeneration) return true;
+      return false;
+    } catch {
+      return true;
+    }
+  }
+  /** section 14.3 (M-3): the database file plus its WAL (free pages are inside the file). A number, content-free. */
+  unifiedDbBytes() {
+    if (this.cfg.storePath === ":memory:") return 0;
+    const size = (p) => {
+      try {
+        return statSync4(p).size;
+      } catch {
+        return 0;
+      }
+    };
+    return size(this.cfg.storePath) + size(`${this.cfg.storePath}-wal`);
+  }
+  /**
+   * Plan Task 31 (Task 33 follow-up): the unified report keys, only while the compiled part 1 switch is on. A store read
+   * that throws omits these keys alone, so the rest of the machine report still posts; the log carries the error class only.
+   */
+  reportedUnified() {
+    if (!this.unifiedOn) return {};
+    try {
+      const a = this.store.unifiedAccounts();
+      const dbBytes = this.unifiedDbBytes();
+      const nearFull = this.store.itemCapState().nearFull || dbBytes > 0.8 * BYTE_CAP_DEFAULT;
+      return { memory_unified_enabled: this.unifiedProviderOn(), memory_size_bytes: a.sizeBytes, memory_item_count: a.itemCount, memory_db_bytes: dbBytes, memory_near_full: nearFull };
+    } catch (e) {
+      writeServiceLog2("warn", "memory.unified_report_failed", {}, e);
+      return {};
+    }
+  }
+  /** U14, R-U20: the switch, provider securecoms, a payload confirmed, the payload on, the local key on, the store enabled. No SQL. */
+  unifiedProviderOn() {
+    return this.unifiedOn && (this.cfg.memoryProvider ?? "securecoms") === "securecoms" && this.memoryConfigConfirmed && this.unifiedConfig.on && this.cfg.memoryEnabled !== false && this.unifiedEnabledMirror;
+  }
   /** Spec §5.3 (H3): mode state lives in the store; level-triggered after every refetch. Never throws. */
   async applyRecallModeFromPayload(mem) {
     try {
@@ -35163,14 +37448,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) {
@@ -35200,8 +37490,10 @@ var BridgeAgent = class _BridgeAgent {
    * but lack an epoch give no recall (fail closed). Never throws.
    */
   async prepareRecallForTurn(t) {
+    if (this.unifiedOn) return;
     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 };
@@ -35214,6 +37506,7 @@ var BridgeAgent = class _BridgeAgent {
   }
   /** ws flush (synchronous). Q1 to Q3 and Q6 again at delivery, on the ORIGINAL message; Q4 lives in withConsumerRecall. */
   recallForDelivery(m) {
+    if (this.unifiedOn) return void 0;
     if (!this.recallProviderOn() || !this.notesReadable(m.authorization)) return void 0;
     return this.recall.deliverable(m.message_id, m.channel_id);
   }
@@ -35306,6 +37599,178 @@ var BridgeAgent = class _BridgeAgent {
   async settleRecallTaps() {
     while (this.recallTapWork.size) await Promise.allSettled([...this.recallTapWork]);
   }
+  /** @internal test seam (plan Task 23): resolves once every in-flight unified item write has settled. */
+  async settleUnifiedWrites() {
+    while (this.unifiedWork.size) await Promise.allSettled([...this.unifiedWork]);
+  }
+  /**
+   * U11: synchronous, the first statement of every unified write. The purge epoch is the receipt one (7b fix H-2). With
+   * the ingest cycle's receipt snapshot (final review bridge M-1), the enable epoch and room-clear generation are the
+   * receipt values too, exactly as for the voice writer; the boot restore re-run has none and reads them now.
+   */
+  captureUnifiedTap(messageId, channelId, receipt) {
+    const capture = receipt ?? this.store.itemCapture(channelId);
+    return { stamp: this.ingestGeneration.get(messageId), capture: { ...capture, purgeEpoch: this.recallStageEpochs.get(messageId)?.purgeEpoch ?? -1 } };
+  }
+  /**
+   * Section 7.1 owner typed, section 7.2 item 1: the frozen memory_write mark, typed (not transcribed, not voice), and the
+   * owner scope from ownerScopeForWrite (H-4: the scope comes only from the owner predicate at write, never from the
+   * audience alone). The capture was taken before this method's first await (U11). Logs are content-free (U17). Never throws.
+   */
+  async tapUnifiedTyped(m, c) {
+    const skip = (reason) => this.logUnifiedTapSkip(reason);
+    try {
+      if (!this.unifiedProviderOn()) return skip("mode");
+      if (m.authorization?.memory_write !== true) {
+        if (this.unifiedAudienceLogged.has(m.channel_id)) return { ok: false, reason: "audience" };
+        if (this.unifiedAudienceLogged.size >= 4096) this.unifiedAudienceLogged.clear();
+        this.unifiedAudienceLogged.add(m.channel_id);
+        return skip("audience");
+      }
+      if (m.transcribed === true || m.voice === true) return skip("voice");
+      if (c.stamp === void 0) return skip("stamp_missing");
+      if (c.capture.purgeEpoch < 0) return skip("purged");
+      const scopeId = await this.ownerScopeForWrite(m.channel_id);
+      if (scopeId === null) return skip("scope");
+      if (parseOwnerDmScopeId(scopeId)?.ownerIdentityId !== m.sender_id) return skip("scope");
+      const r = await this.items.commit({
+        scopeKind: "owner_dm",
+        scopeId,
+        channelId: m.channel_id,
+        kind: "auto",
+        originId: m.message_id,
+        originAt: m.ts,
+        source: "owner_typed",
+        trust: "owner",
+        text: typeof m.text === "string" ? m.text : "",
+        expect: { ...c.capture, clearGeneration: c.stamp }
+      });
+      return r.ok ? { ok: true } : { ok: false, reason: r.reason };
+    } catch {
+      return skip("store");
+    }
+  }
+  /**
+   * Section 7.2 item 2 (R-U7, E-1; amended by Eric 2026-10-11, "Fix voice"): exactly ownerRelayed (relay_speaker === "owner",
+   * frozen at receipt) AND a window-eligible turn (voiceWindowEligible), whatever the window size. Two call sites: the voice
+   * window flush, and the ingest tap block when the window did not take the turn (off, 0 by default). Like the typed tap, the write-time owner scope's pinned identity must be the speaking identity;
+   * otherwise nothing is written (H-4). Logs are content-free (U17). Never throws.
+   */
+  async tapUnifiedVoice(m, c) {
+    const skip = (reason) => this.logUnifiedTapSkip(reason);
+    try {
+      if (!this.unifiedProviderOn()) return skip("mode");
+      if (m.authorization?.relay_speaker !== "owner" || m.speaker === void 0) return skip("audience");
+      if (c.stamp === void 0) return skip("stamp_missing");
+      if (c.capture.purgeEpoch < 0) return skip("purged");
+      const scopeId = await this.ownerScopeForWrite(m.channel_id);
+      if (scopeId === null) return skip("scope");
+      if (parseOwnerDmScopeId(scopeId)?.ownerIdentityId !== m.speaker.identityId) return skip("scope");
+      const r = await this.items.commit({
+        scopeKind: "owner_dm",
+        scopeId,
+        channelId: m.channel_id,
+        kind: "auto",
+        originId: m.message_id,
+        originAt: m.ts,
+        source: "owner_voice",
+        trust: OWNER_VOICE_TRUST,
+        text: typeof m.text === "string" ? m.text : "",
+        expect: { ...c.capture, clearGeneration: c.stamp }
+      });
+      return r.ok ? { ok: true } : { ok: false, reason: r.reason };
+    } catch {
+      return skip("store");
+    }
+  }
+  /** Section 8.1 steps 1 to 7, before the turn is staged. H-4: the frozen owner predicate and the owner scope now. Never throws. */
+  async prepareUnifiedForTurn(t) {
+    try {
+      if (!this.unifiedProviderOn()) return;
+      if (!(t.authorization.memory_write === true || t.authorization.relay_speaker === "owner")) return;
+      const scopeId = this.ownerScopeNow(t.channelId);
+      if (scopeId === null) return;
+      if (t.authorization.memory_write === true && !this.migrationStarted.has(t.channelId)) this.startUnifiedMigration(t.channelId);
+      await this.unifiedReads.prepare({ messageId: t.messageId, channelId: t.channelId, scopeId, text: t.text, kind: t.kind });
+    } catch (e) {
+      writeServiceLog2("warn", "memory.unified_prepare_failed", {}, e);
+    }
+  }
+  /**
+   * Plan Task 30 (spec section 14.1, M-1, OQ-P1): migrate this one conversation in the background. The owner identity comes
+   * from ownerScopeForWrite (the pinned owner, roster fresh at write; never the audience alone, H-4) and the classification
+   * from the persisted isDm: non-DM is excluded (M-4); no persisted flag or no owner scope is unknown, and an unknown or
+   * stopped run (U11) is retried by a later owner turn.
+   */
+  startUnifiedMigration(channelId) {
+    this.migrationStarted.add(channelId);
+    const work = (async () => {
+      const scopeId = await this.ownerScopeForWrite(channelId);
+      const ownerId = scopeId === null ? void 0 : parseOwnerDmScopeId(scopeId)?.ownerIdentityId;
+      const classify = (c) => {
+        const isDm = c === channelId ? this.store.getChannelMeta(c)?.isDm : void 0;
+        if (isDm === false) return { kind: "excluded" };
+        if (isDm !== true || ownerId === void 0) return { kind: "unknown" };
+        return this.store.recordDmOwner(c, ownerId) ? { kind: "owner", ownerId } : { kind: "unknown" };
+      };
+      const out = await runMigration({
+        store: this.store,
+        items: this.items,
+        classify,
+        stopping: () => this.closingDown,
+        pinsChanged: () => this.notes.exclusive(async () => {
+          this.unifiedReads?.bumpGeneration();
+        })
+      }, { only: channelId });
+      if (out.skipped > 0 || out.aborted > 0) this.migrationStarted.delete(channelId);
+    })().catch((e) => {
+      this.migrationStarted.delete(channelId);
+      writeServiceLog2("warn", "memory.migration_failed", {}, e);
+    });
+    this.unifiedWork.add(work);
+    void work.finally(() => this.unifiedWork.delete(work));
+  }
+  /** ws flush (synchronous). The predicate and the owner scope again at delivery, on the ORIGINAL message (H-4, Review Focus 3). */
+  unifiedForDelivery(m) {
+    if (!this.unifiedProviderOn()) return void 0;
+    const a = m.authorization;
+    if (!(a?.memory_write === true || a?.relay_speaker === "owner")) return void 0;
+    const scopeId = this.ownerScopeNow(m.channel_id);
+    return scopeId === null ? void 0 : this.unifiedReads.deliverable(m.message_id, m.channel_id, scopeId);
+  }
+  /** ws-server: the hello echoes memory_unified only with the part 1 switch compiled on. */
+  unifiedFeatureOn() {
+    return this.unifiedOn;
+  }
+  /** ws-server: a runtime socket with no harness claim declared memory_unified. */
+  noteUnifiedConsumer() {
+    this.unifiedConsumerSeen = true;
+  }
+  /** One content-free unified-tap skip line (reason class only, U17). */
+  logUnifiedTapSkip(reason) {
+    writeServiceLog2("info", "memory.item_skipped", { reason_class: ServiceLogEnum.of(reason, ["mode", "audience", "voice", "stamp_missing", "purged", "scope", "store"]) });
+    return { ok: false, reason };
+  }
+  /** Fire-and-forget unified tap from the ingest cycle; tracked so close() and tests can wait for it. */
+  spawnUnifiedTap(m, c) {
+    const work = this.tapUnifiedTyped(m, c);
+    this.unifiedWork.add(work);
+    void work.finally(() => this.unifiedWork.delete(work));
+  }
+  /** The 7b M1/H-1 rule for the unified writer: turns staged before the boot config settled, tapped once it has. A turn no longer held is skipped. */
+  async reindexUnifiedRestored() {
+    const ids = [...this.deferredUnifiedIds];
+    this.deferredUnifiedIds.clear();
+    const byId = new Map(this.buffer.map((m) => [m.message_id, m]));
+    for (const id of ids) {
+      const m = byId.get(id);
+      if (m === void 0) {
+        this.logUnifiedTapSkip("stamp_missing");
+        continue;
+      }
+      await this.tapUnifiedTyped(m, this.captureUnifiedTap(id, m.channel_id));
+    }
+  }
   /**
    * Spec §4 M1: after the boot refetch settles, tap the deferred turns: those
    * restored from runtime_inbox (a crash between staging and the tap) and
@@ -35315,6 +37780,7 @@ var BridgeAgent = class _BridgeAgent {
    * receipt epochs (fix H-2). A turn no longer held logs `stamp_missing`.
    */
   async reindexRestoredTurns() {
+    if (this.unifiedOn) return;
     const ids = [...this.deferredRecallIds];
     this.deferredRecallIds.clear();
     const byId = new Map(this.buffer.map((m) => [m.message_id, m]));
@@ -35351,7 +37817,7 @@ var BridgeAgent = class _BridgeAgent {
   async runRecallMaintenanceTick(n) {
     const now = Date.now();
     const root3 = defaultModelsRoot(this.home);
-    if (this.machinePaths && this.recallProviderOn() && this.embedder.filesPresent() && now - this.lastMarkerTouchAt >= 864e5) {
+    if (this.machinePaths && (this.recallProviderOn() || this.unifiedProviderOn()) && this.embedder.filesPresent() && now - this.lastMarkerTouchAt >= 864e5) {
       this.lastMarkerTouchAt = now;
       try {
         touchUserMarker(root3, EMBEDDING_MANIFEST.modelId, this.cfg.identityId);
@@ -35367,9 +37833,21 @@ var BridgeAgent = class _BridgeAgent {
         writeServiceLog2("warn", "memory.model_upkeep_failed", {}, e);
       }
     }
+    if (this.unifiedOn) {
+      if (this.unifiedProviderOn() && (this.itemReembedHot || n % 60 === 0)) {
+        try {
+          this.itemReembedHot = await this.itemReembed.tick() > 0;
+        } catch (e) {
+          this.itemReembedHot = false;
+          writeServiceLog2("warn", "memory.reembed_failed", {}, e);
+        }
+      }
+      return;
+    }
     if (!this.recallProviderOn()) {
       this.reembedHot = false;
       this.recallPrewarmPending = false;
+      this.recallPrewarmTargets.clear();
       return;
     }
     this.runRecallPrewarm();
@@ -35471,6 +37949,7 @@ var BridgeAgent = class _BridgeAgent {
    * generation the socket records for W7b.
    */
   notesForDelivery(m) {
+    if (this.unifiedOn) return { generation: this.notes.appliedGeneration() };
     const generation = this.notes.appliedGeneration();
     if (!this.notesReadable(m.authorization)) return { generation };
     const d = this.notes.deliverable(m.channel_id);
@@ -35486,6 +37965,7 @@ var BridgeAgent = class _BridgeAgent {
    * only); the turn's own frozen authorization is the proof NotesBook checks.
    */
   async prepareNotesForTurn(channelId, a) {
+    if (this.unifiedOn) return;
     if (!this.notesReadable(a)) return;
     try {
       if (a.memory_write === true && this.bootConfigSettled && this.notesConsumerSeen) await this.notes.importLegacy(channelId, a);
@@ -35531,10 +38011,11 @@ var BridgeAgent = class _BridgeAgent {
    * taken; nothing under the mutex awaits it.
    */
   async applyMemoryNote(raw, ctx) {
+    if (this.unifiedOn) return this.applyUnifiedNote(raw, ctx);
     const ids = echoIds(raw);
     const refuse = (reason, echo = ids) => {
       writeServiceLog2("info", "memory.note_refused", {
-        reason_class: ServiceLogEnum.of(reason, ["mode", "invalid", "message", "audience", "provenance", "secret", "cap", "cleared", "store", "budget", "purged"])
+        reason_class: ServiceLogEnum.of(reason, ["mode", "invalid", "message", "audience", "provenance", "secret", "cap", "cleared", "store", "budget", "purged", "not_owner_words"])
       });
       return { type: "memory_note_result", ...echo, ok: false, reason };
     };
@@ -35626,6 +38107,122 @@ var BridgeAgent = class _BridgeAgent {
       ctx.pendingRequests.delete(f.request_id);
     }
   }
+  /**
+   * Spec section 7.4 (pins) and section 14.4 (forget, Task 29), under unified memory. Order: W1, well formed, W2, W3,
+   * W4(a), W4(b), then for a pin: the C-1 allowlist (with R2-L-1), H-1 coverage on the stripped bytes, W5 (secret), the
+   * 400-character cap, W7b (the ingest stamp), the commit under U11 with W1/W2 re-checked first inside the mutex (the
+   * 200-pin cap is in the store transaction), then the bridge-authored `Pinned:` line. `replace` is refused (OQ-P4,
+   * fail closed). Every reason sent is a key of the runtime's UNIFIED_REFUSAL.
+   */
+  async applyUnifiedNote(raw, ctx) {
+    const ids = echoIds(raw);
+    const refuse = (reason, echo = ids) => {
+      writeServiceLog2("info", "memory.note_refused", {
+        reason_class: ServiceLogEnum.of(reason, ["mode", "invalid", "message", "audience", "provenance", "secret", "cap", "cleared", "store", "budget", "purged", "not_owner_words"])
+      });
+      return { type: "memory_note_result", ...echo, ok: false, reason };
+    };
+    if (!this.unifiedProviderOn()) return refuse("mode");
+    const f = parseMemoryNoteFrame(raw);
+    if (!f) return refuse("invalid");
+    if (ctx.pendingRequests.has(f.request_id)) return refuse("invalid", { message_id: f.message_id });
+    if (ctx.pendingRequests.size >= MAX_PENDING_NOTE_REQUESTS) return refuse("invalid", {});
+    ctx.pendingRequests.add(f.request_id);
+    try {
+      const w2 = () => {
+        const s = ctx.session;
+        if (s.consumer !== "runtime" || s.harnessClaimed === true) return void 0;
+        const cur = ctx.lookup(f.message_id);
+        if (cur === void 0 || this.isRuntimeMessageRetired(f.message_id)) return void 0;
+        if (ctx.token === void 0 || cur.token !== ctx.token) return void 0;
+        return cur.record;
+      };
+      const rec = w2();
+      if (rec === void 0) return refuse("message");
+      const channelId = rec.channel_id;
+      if (rec.authorization?.memory_write !== true) return refuse("audience");
+      const held = await this.heldPosition(channelId);
+      if (this.authorizationFor(channelId, rec.sender_id, void 0, held.epoch, held.groupId, { log: false }).memory_write !== true) return refuse("audience");
+      const scopeId = this.ownerScopeNow(channelId);
+      if (scopeId === null) return refuse("audience");
+      const precommit = () => !this.unifiedProviderOn() ? "mode" : w2() !== rec ? "message" : null;
+      if (f.op === "replace") return refuse("invalid");
+      if (f.op === "forget") return await this.forgetUnified(f, rec, channelId, ctx, refuse, precommit);
+      const stripped = allowlistPin(f.text);
+      if (stripped.trim().length === 0) return refuse("invalid");
+      const shown = ctx.shownUnified(f.message_id, ctx.token) ?? /* @__PURE__ */ new Set();
+      if (!pinCoverage(stripped, rec.text, this.unifiedReads.coverageTexts(f.message_id, shown)).ok) return refuse("not_owner_words");
+      if (scanNote(stripped) !== null) return refuse("secret");
+      if (stripped.length > PIN_MAX_CHARS) return refuse("cap");
+      const stamp = this.ingestGeneration.get(rec.message_id);
+      if (stamp === void 0) return refuse("cleared");
+      const capture = this.store.itemCapture(channelId);
+      const r = await this.items.commit({
+        scopeKind: "owner_dm",
+        scopeId,
+        channelId,
+        kind: "pinned",
+        originId: `pin:${rec.message_id}:${f.request_id}`,
+        originAt: Date.now(),
+        source: "owner_pin",
+        trust: "owner",
+        text: stripped,
+        noChunk: true,
+        expect: { ...capture, clearGeneration: stamp },
+        precommit
+      });
+      if (!r.ok) {
+        const map = { pin_cap: "cap", secret: "secret", cleared: "cleared", room_cleared: "cleared", disabled: "mode", mode: "mode", purged: "purged", message: "message", duplicate: "invalid", invalid: "invalid", empty: "invalid" };
+        return refuse(map[r.reason] ?? "store");
+      }
+      await this.notes.exclusive(async () => this.unifiedReads.bumpGeneration());
+      void this.send(channelId, pinnedLine(stripped), void 0, { agentTurn: false }).catch((e) => writeServiceLog2("warn", "memory.pinned_line_failed", {}, e));
+      writeServiceLog2("info", "memory.pin_written");
+      return { type: "memory_note_result", request_id: f.request_id, message_id: f.message_id, ok: true, id: r.itemIds[0] };
+    } catch (e) {
+      writeServiceLog2("warn", "memory.note_write_failed", {}, e);
+      return refuse("store");
+    } finally {
+      ctx.pendingRequests.delete(f.request_id);
+    }
+  }
+  /**
+   * Spec section 14.4 ("Forget that", M-5), U13, R-U21; plan Task 29. Reached from applyUnifiedNote after W1 to W4(b) and
+   * the owner scope check (owner DM only, a typed owner turn; voice never forgets, R-U7). Only an `r<id>` of an item shown
+   * with THIS delivery of THIS message on THIS socket; its delivered text must still be known (plan audit M-6) before the
+   * message's one destructive operation (W9) is prepared. The delete (item group, matching 7a/7b row, 7b tombstone for a
+   * message origin, W9 spend) is one store transaction under the memory mutex, with W1/W2 re-checked first; the read book
+   * is invalidated in the same mutex hold, the item leaves the ranking hot set, then the bridge publishes `Forgot:`
+   * (OQ-P2: afterPublish keeps the line out of history and the items). Every reason is a key of UNIFIED_REFUSAL.
+   */
+  async forgetUnified(f, rec, channelId, ctx, refuse, precommit) {
+    if (typeof f.id !== "object") return refuse("invalid");
+    const itemId = f.id.recall;
+    const shown = ctx.shownUnified(f.message_id, ctx.token);
+    if (!shown || !shown.has(itemId)) return refuse("invalid");
+    const text = this.unifiedReads.shownText(f.message_id, itemId);
+    if (text === void 0) return refuse("invalid");
+    const rw = await this.store.prepareRuntimeInboxRewrite(rec.message_id, bumpW9);
+    if (rw === "declined") return refuse("budget");
+    if (rw === "no_row") return refuse("message");
+    const r = await this.notes.exclusive(async () => {
+      const veto = precommit();
+      if (veto !== null) return { ok: false, reason: veto };
+      if (rw.messageId !== rec.message_id) return { ok: false, reason: "message" };
+      const out = this.store.forgetItem(itemId, rw, channelId);
+      if (out.ok) {
+        this.unifiedReads.dropChannelLocked(out.channelId);
+        if (out.channelId !== channelId) this.unifiedReads.dropChannelLocked(channelId);
+        this.unifiedReads.forgetShown(f.message_id, itemId);
+      }
+      return out;
+    });
+    if (!r.ok) return refuse(r.reason === "unknown_id" ? "invalid" : r.reason);
+    this.rankingNote(() => this.ranking.removed(r.itemIds));
+    void this.send(channelId, forgotLine(text), void 0, { agentTurn: false }).catch((e) => writeServiceLog2("warn", "memory.forgot_line_failed", {}, e));
+    writeServiceLog2("info", "memory.item_forgotten");
+    return { type: "memory_note_result", request_id: f.request_id, message_id: f.message_id, ok: true };
+  }
   async memoryContext(conversationId, limit) {
     if (!await this.mayReadOpenClawMemory(conversationId)) {
       return { recent: [], facts: [] };
@@ -36419,8 +39016,8 @@ var BridgeAgent = class _BridgeAgent {
   async reportStatus(channelId, state, detail) {
     const joined = await this.reconcileJoin(channelId);
     if (!joined) throw new ChannelPendingError(channelId);
-    const enc4 = this.store.getChannelMeta(channelId)?.enclaveId;
-    if (!enc4) return;
+    const enc5 = this.store.getChannelMeta(channelId)?.enclaveId;
+    if (!enc5) return;
     await sendWithSelfHeal(
       this.provider,
       channelId,
@@ -36429,7 +39026,7 @@ var BridgeAgent = class _BridgeAgent {
         groupKey: this.provider,
         messageId: crypto.randomUUID(),
         channelId,
-        enclaveId: enc4,
+        enclaveId: enc5,
         senderId: this.cfg.identityId,
         senderType: "agent",
         type: "system_event",
@@ -36934,11 +39531,13 @@ var BridgeAgent = class _BridgeAgent {
     if (!entries.length) return;
     const receivedAt = Date.now();
     const purgeEpochAtReceipt = /* @__PURE__ */ new Map();
+    const itemCaptureAtReceipt = /* @__PURE__ */ new Map();
     const recallModeEpochAtReceipt = this.store.recallState().modeEpoch;
     for (const m of entries) {
       this.lastInboundAt.set(m.channelId, receivedAt);
       if (m.voiceMode === true) this.heartbeat.noteVoiceActivity();
       if (!purgeEpochAtReceipt.has(m.channelId)) purgeEpochAtReceipt.set(m.channelId, this.store.conversationPurgeEpoch(m.channelId));
+      if (this.unifiedOn && !itemCaptureAtReceipt.has(m.channelId)) itemCaptureAtReceipt.set(m.channelId, this.store.itemCapture(m.channelId));
       this.recallReceipt.set(m.messageId, { purgeEpoch: purgeEpochAtReceipt.get(m.channelId), modeEpoch: recallModeEpochAtReceipt });
       receiptIds.push(m.messageId);
     }
@@ -37163,10 +39762,12 @@ var BridgeAgent = class _BridgeAgent {
             const fastPathEligible = Boolean(m.voiceMode && humanTurn && this.fastLlm && voiceGuidance);
             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;
+            const windowEligible = voiceWindowEligible({ voiceMode: m.voiceMode, speaker, transcribed: parsed.transcribed, voiceGuidance, isCallStart });
+            const coalescible = this.voiceCoalesceWindowMs > 0 && windowEligible;
             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 });
+              if (this.unifiedOn) await this.prepareUnifiedForTurn({ channelId: m.channelId, messageId: m.messageId, text: parsed.text, authorization: turnAuthorization, kind: kind2 });
+              else 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) {
@@ -37235,7 +39836,8 @@ var BridgeAgent = class _BridgeAgent {
                 parts: [turnText],
                 closed: false,
                 pending: Promise.resolve(),
-                purgeEpoch: purgeEpochAtReceipt.get(m.channelId)
+                purgeEpoch: purgeEpochAtReceipt.get(m.channelId),
+                itemCapture: itemCaptureAtReceipt.get(m.channelId)
               };
               this.voiceCoalescing.set(windowKey, win);
               const openedAt = Date.now();
@@ -37251,8 +39853,15 @@ 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, kind: "voice" });
+                if (this.unifiedOn) await this.prepareUnifiedForTurn({ channelId, messageId: firstId, text, authorization: turnAuthorization, kind: "voice" });
+                else await this.prepareRecallForTurn({ channelId, messageId: firstId, text, authorization: turnAuthorization, kind: "voice" });
                 const merged = { ...held, text };
+                if (this.unifiedOn) {
+                  const snap = win.itemCapture ?? { ...this.store.itemCapture(channelId), purgeEpoch: -1 };
+                  const work = this.tapUnifiedVoice(merged, { stamp: this.ingestGeneration.get(firstId), capture: { ...snap, purgeEpoch: win.purgeEpoch ?? -1 } });
+                  this.unifiedWork.add(work);
+                  void work.finally(() => this.unifiedWork.delete(work));
+                }
                 void recordInboundMemory(this.memory, channelId, senderId, text, firstId, "voice", win.purgeEpoch);
                 let roomBlocked = false;
                 if (fastPathEligible && isRoom) {
@@ -37326,7 +39935,21 @@ var BridgeAgent = class _BridgeAgent {
             }
             const purgeEpochAtTap = purgeEpochAtReceipt.get(m.channelId);
             if (!this.bootConfigSettled) {
-              this.deferredRecallIds.add(m.messageId);
+              if (this.unifiedOn) this.deferredUnifiedIds.add(m.messageId);
+              else this.deferredRecallIds.add(m.messageId);
+            } else if (this.unifiedOn) {
+              if (this.unifiedProviderOn()) {
+                this.spawnUnifiedTap(
+                  runtimeEntry(false, { recent: [], facts: [] }),
+                  this.captureUnifiedTap(m.messageId, m.channelId, itemCaptureAtReceipt.get(m.channelId) ?? { ...this.store.itemCapture(m.channelId), purgeEpoch: -1 })
+                );
+                if (windowEligible && turnAuthorization.relay_speaker === "owner") {
+                  const snap = itemCaptureAtReceipt.get(m.channelId) ?? { ...this.store.itemCapture(m.channelId), purgeEpoch: -1 };
+                  const work = this.tapUnifiedVoice(runtimeEntry(false, { recent: [], facts: [] }), { stamp: this.ingestGeneration.get(m.messageId), capture: { ...snap, purgeEpoch: purgeEpochAtReceipt.get(m.channelId) ?? -1 } });
+                  this.unifiedWork.add(work);
+                  void work.finally(() => this.unifiedWork.delete(work));
+                }
+              }
             } else if (this.recallProviderOn()) {
               const recallTap = this.captureRecallTap(m.messageId, m.channelId);
               this.spawnRecallTap({ message: runtimeEntry(false, { recent: [], facts: [] }), captured: recallTap });
@@ -37548,6 +40171,7 @@ var BridgeAgent = class _BridgeAgent {
     const now = Date.now();
     for (const m of messages) {
       this.recall.drop(m.message_id);
+      this.unifiedReads?.drop(m.message_id);
       const attempts = this.deliveryAttempts.get(m.message_id) ?? 0;
       if (attempts >= this.maxDeliveryAttempts) {
         this.deadLetter(m, attempts);
@@ -37751,6 +40375,7 @@ var BridgeAgent = class _BridgeAgent {
       this.ingestGeneration.delete(messageId);
       this.recallStageEpochs.delete(messageId);
       this.recall.drop(messageId);
+      this.unifiedReads?.drop(messageId);
       this.deliveryAttempts.delete(messageId);
       this.redeliverNotBefore.delete(messageId);
       this.supersedeRefundable.delete(messageId);
@@ -37820,7 +40445,8 @@ var BridgeAgent = class _BridgeAgent {
       const message = rest;
       this.applyStagedMarks(message.message_id, marks);
       this.runtimePendingIds.add(message.message_id);
-      this.deferredRecallIds.add(message.message_id);
+      if (this.unifiedOn) this.deferredUnifiedIds.add(message.message_id);
+      else this.deferredRecallIds.add(message.message_id);
       if (row.deliveryAttempts > 0) {
         this.deliveryAttempts.set(message.message_id, row.deliveryAttempts);
         if (row.deliveryAttempts < this.maxDeliveryAttempts) {
@@ -37998,6 +40624,13 @@ var BridgeAgent = class _BridgeAgent {
       // INV-CUSTODY-DURABLE §5.C.3: custody health.
       expired_drained: this.provider.expiredDrainedCount(),
       recall_cache_bytes: this.recall.cacheBytes(),
+      ...this.unifiedOn ? {
+        memory_hot_bytes: this.ranking.hotBytes(),
+        memory_deadline_misses: this.unifiedReads?.deadlineMisses() ?? 0,
+        memory_reads: this.unifiedReads?.readsAttempted() ?? 0,
+        memory_reads_discarded: this.unifiedReads?.readsDiscarded() ?? 0,
+        pid: process.pid
+      } : {},
       custody_persist_failing: this.provider.custodyHealth().persistFailing,
       custody_persist_failures: this.provider.custodyHealth().persistFailures,
       custody_read_failing: this.provider.custodyHealth().readFailing,
@@ -38131,6 +40764,16 @@ var BridgeAgent = class _BridgeAgent {
       ]);
       if (timer) clearTimeout(timer);
     }
+    if (this.unifiedWork.size) {
+      let timer;
+      await Promise.race([
+        Promise.allSettled([...this.unifiedWork]),
+        new Promise((resolve) => {
+          timer = setTimeout(resolve, _BridgeAgent.GRACEFUL_DRAIN_MS);
+        })
+      ]);
+      if (timer) clearTimeout(timer);
+    }
     if (this.recallPrewarmWork) {
       let timer;
       await Promise.race([
@@ -38153,18 +40796,19 @@ var BridgeAgent = class _BridgeAgent {
       if (timer) clearTimeout(timer);
     }
     await this.provider.drainInFlight(_BridgeAgent.GRACEFUL_DRAIN_MS);
+    await this.ranking.close();
     this.store.close();
   }
 };
 
 // src/config.ts
-import { readFileSync as readFileSync9, statSync as statSync4 } from "node:fs";
-import { dirname as dirname5, join as join16 } from "node:path";
+import { readFileSync as readFileSync9, statSync as statSync5 } from "node:fs";
+import { dirname as dirname5, join as join17 } from "node:path";
 var REQUIRED = ["api_key", "identity_id", "device_id", "signing_private_key", "enclave_id", "api_base"];
 function loadConfig(opts) {
   const raw = readFileSync9(opts.credentialPath, "utf8");
   try {
-    const mode = statSync4(opts.credentialPath).mode & 511;
+    const mode = statSync5(opts.credentialPath).mode & 511;
     if (mode & 63) writeServiceLog2("warn", "config.credential_permissions_unsafe");
   } catch {
   }
@@ -38175,7 +40819,7 @@ function loadConfig(opts) {
     throw new Error("credential file is not valid JSON");
   }
   for (const k of REQUIRED) if (typeof json2[k] !== "string" || !json2[k]) throw new Error(`credential file missing required field: ${k}`);
-  const storePath = opts.storePath ?? join16(dirname5(opts.credentialPath), "bridge-state.db");
+  const storePath = opts.storePath ?? join17(dirname5(opts.credentialPath), "bridge-state.db");
   const agentName = typeof json2.agent_name === "string" && json2.agent_name ? json2.agent_name : typeof json2.display_name === "string" && json2.display_name ? json2.display_name : void 0;
   const rateLimitCapacity = typeof json2.rate_limit_capacity === "number" ? json2.rate_limit_capacity : 20;
   const rateLimitRefillPerMinute = typeof json2.rate_limit_refill_per_minute === "number" ? json2.rate_limit_refill_per_minute : 20;
@@ -38212,6 +40856,8 @@ function loadConfig(opts) {
     throw new Error(`credential file voice config invalid: ${e.message}`);
   }
   const modelSource = json2.memory?.model_source === "import_only" ? "import_only" : "download";
+  const enabledRaw = json2.memory?.enabled;
+  const memoryEnabled = enabledRaw === void 0 || enabledRaw === true;
   return {
     apiKey: json2.api_key,
     identityId: json2.identity_id,
@@ -38230,7 +40876,8 @@ function loadConfig(opts) {
     memoryFactsCharBudget,
     voice,
     voiceFastPathMode: parseFastPathMode(json2.voice_fast_path_mode),
-    modelSource
+    modelSource,
+    memoryEnabled
   };
 }
 function arg(argv, flag) {
@@ -38746,6 +41393,15 @@ function withConsumerRecall(out, original, session, src) {
   return { message: { ...out, memory }, shown: new Set(items.map((i) => i.id)) };
 }
 
+// src/memory/unified/consumer-unified.ts
+function withConsumerUnified(out, original, session, src) {
+  if (session.consumer !== "runtime" || session.harnessClaimed === true || !session.unifiedConsumer) return { message: out, shown: /* @__PURE__ */ new Set() };
+  const u = src.unifiedForDelivery(original);
+  if (!u || u.items.length === 0 && u.pinnedMore === 0) return { message: out, shown: /* @__PURE__ */ new Set() };
+  const memory = { ...out.memory ?? {}, unified: { items: u.items, pinned_more: u.pinnedMore } };
+  return { message: { ...out, memory }, shown: new Set(u.items.map((i) => i.id)) };
+}
+
 // src/ws-server.ts
 var PING_INTERVAL_MS = 3e4;
 var INFLIGHT_STALE_SWEEP_MS = 6e4;
@@ -38753,6 +41409,7 @@ var INFLIGHT_STALE_AFTER_MS = 15 * 6e4;
 var HELLO_WAIT_MS = 2e3;
 var MEMORY_NOTES_FEATURE = "memory_notes";
 var MEMORY_RECALL_FEATURE = "memory_recall";
+var MEMORY_UNIFIED_FEATURE = "memory_unified";
 function tokenFromUpgrade(req) {
   try {
     const url = new URL(req.url ?? "/", "http://localhost");
@@ -38821,7 +41478,9 @@ function attachAgentWebSocket(server, agent, opts) {
       deliverySeq: 0,
       pendingNoteRequests: /* @__PURE__ */ new Set(),
       recallConsumer: false,
-      shownRecall: /* @__PURE__ */ new Map()
+      shownRecall: /* @__PURE__ */ new Map(),
+      unifiedConsumer: false,
+      shownUnified: /* @__PURE__ */ new Map()
     };
     const sweepStale = () => {
       const at = now();
@@ -38850,6 +41509,7 @@ function attachAgentWebSocket(server, agent, opts) {
             inflight.delete(id);
             session.deliveryToken.delete(id);
             session.shownRecall.delete(id);
+            session.shownUnified.delete(id);
           } else busy.add(m.channel_id);
         }
         const batch = agent.takeDeliverable(busy);
@@ -38866,12 +41526,14 @@ function attachAgentWebSocket(server, agent, opts) {
           }
           const out = withConsumerNotes(withConsumerGrants(batch[i], session.perToolGrants), batch[i], session, agent);
           const recallOut = withConsumerRecall(out.message, batch[i], session, agent);
-          const frame = { type: "message", ...recallOut.message };
+          const unifiedOut = withConsumerUnified(recallOut.message, batch[i], session, agent);
+          const frame = { type: "message", ...unifiedOut.message };
           try {
             sock.send(JSON.stringify(frame));
             inflight.set(batch[i].message_id, batch[i]);
             session.deliveryToken.set(batch[i].message_id, ++session.deliverySeq);
             session.shownRecall.set(batch[i].message_id, { token: session.deliverySeq, ids: recallOut.shown });
+            session.shownUnified.set(batch[i].message_id, { token: session.deliverySeq, ids: unifiedOut.shown });
             delivered.set(batch[i].message_id, { at: now(), logged: false });
           } catch {
             agent.requeueFront(batch.slice(i));
@@ -38906,6 +41568,7 @@ function attachAgentWebSocket(server, agent, opts) {
       delivered.clear();
       session.deliveryToken.clear();
       session.shownRecall.clear();
+      session.shownUnified.clear();
       session.pendingNoteRequests.clear();
       if (current?.sock === sock) current = null;
       if (session.harness) agent.clearHarnessReport(session.harness);
@@ -38969,6 +41632,7 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
     inflight.delete(m.message_id);
     session.deliveryToken.delete(m.message_id);
     session.shownRecall.delete(m.message_id);
+    session.shownUnified.delete(m.message_id);
     agent.ackRuntimeMessages([m.message_id]);
     flush();
     return;
@@ -38993,7 +41657,9 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
     }
     session.recallConsumer = session.consumer === "runtime" && session.harnessClaimed !== true && Array.isArray(m.features) && m.features.includes(MEMORY_RECALL_FEATURE);
     if (session.recallConsumer) agent.noteRecallConsumer();
-    sendJson(sock, { type: "hello", features: ["nack", MEMORY_NOTES_FEATURE, MEMORY_RECALL_FEATURE] });
+    session.unifiedConsumer = agent.unifiedFeatureOn() && session.consumer === "runtime" && session.harnessClaimed !== true && Array.isArray(m.features) && m.features.includes(MEMORY_UNIFIED_FEATURE);
+    if (session.unifiedConsumer) agent.noteUnifiedConsumer();
+    sendJson(sock, { type: "hello", features: ["nack", MEMORY_NOTES_FEATURE, MEMORY_RECALL_FEATURE, ...agent.unifiedFeatureOn() ? [MEMORY_UNIFIED_FEATURE] : []] });
     if (!session.deliveryOpen) {
       session.deliveryOpen = true;
       flush();
@@ -39010,6 +41676,7 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
     inflight.delete(m.message_id);
     session.deliveryToken.delete(m.message_id);
     session.shownRecall.delete(m.message_id);
+    session.shownUnified.delete(m.message_id);
     if (agent.isRuntimeMessageRetired(m.message_id)) {
       flush();
       return;
@@ -39025,6 +41692,7 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
       inflight.delete(inReplyTo);
       session.deliveryToken.delete(inReplyTo);
       session.shownRecall.delete(inReplyTo);
+      session.shownUnified.delete(inReplyTo);
       agent.ackRuntimeMessages([inReplyTo]);
     }
     sendJson(sock, { ...wsErrorFrame(code), ...typeof inReplyTo === "string" ? { in_reply_to: inReplyTo } : {} });
@@ -39122,6 +41790,10 @@ async function handleInbound(sock, agent, data, inflight, flush, session) {
       shownRecall: (messageId, token) => {
         const s = session.shownRecall.get(messageId);
         return s !== void 0 && token !== void 0 && s.token === token ? s.ids : void 0;
+      },
+      shownUnified: (messageId, token) => {
+        const s = session.shownUnified.get(messageId);
+        return s !== void 0 && token !== void 0 && s.token === token ? s.ids : void 0;
       }
     });
     sendJson(sock, result);