@securecoms/agent-bridge 0.19.0 → 0.21.0

package/dist/index.js

@@ -5172,8 +5172,11 @@ var RestMlsBackend = class {
       queue_ids: queueIds
     });
   }
-  async nackDelivery(_deviceId, queueIds) {
-    await this.post("/api/v1/mls/delivery/nack", { queue_ids: queueIds });
+  async nackDelivery(deviceId, queueIds) {
+    await this.post("/api/v1/mls/delivery/nack", {
+      device_id: deviceId,
+      queue_ids: queueIds
+    });
   }
   async listGroupMessages(deviceId, groupId, opts) {
     const params = new URLSearchParams({ device_id: deviceId, limit: String(opts?.limit ?? 100) });
@@ -5681,7 +5684,7 @@ import { DatabaseSync } from "node:sqlite";
 import { MLSGroupManager as MLSGroupManager3, bytesToHex as bytesToHex4, hexToBytes as hexToBytes3 } from "@agentvault/crypto";
 
 // ../connect-mls-store/dist/schema.js
-var SCHEMA_VERSION = 6;
+var SCHEMA_VERSION = 7;
 function openSchema(db) {
   db.exec("PRAGMA journal_mode=WAL");
   const row = db.prepare("PRAGMA user_version").get();
@@ -5773,6 +5776,17 @@ function openSchema(db) {
       );
     `);
   }
+  if (row.user_version < 7) {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_memory_fact_assignment (
+        identity_id     TEXT NOT NULL,
+        assignment_key  TEXT NOT NULL,
+        conversation_id TEXT NOT NULL,
+        applied_at      INTEGER NOT NULL,
+        PRIMARY KEY (identity_id, assignment_key)
+      );
+    `);
+  }
   db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
 }
 
@@ -5812,6 +5826,10 @@ function decodeBundle(bytes) {
     }
   };
 }
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MEMORY_RETENTION_MS = 30 * DAY_MS;
+var DEFAULT_MEMORY_FACT_RETENTION_K = 200;
+var DEFAULT_MEMORY_FACT_RETENTION_MS = 90 * DAY_MS;
 var SqliteMlsStateStore = class {
   db;
   id;
@@ -5825,6 +5843,10 @@ var SqliteMlsStateStore = class {
   bundles = /* @__PURE__ */ new Map();
   lastKpIds = /* @__PURE__ */ new Map();
   memoryRetentionK;
+  memoryRetentionMs;
+  memoryFactRetentionK;
+  memoryFactRetentionMs;
+  memoryNow;
   // 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
@@ -5839,6 +5861,10 @@ var SqliteMlsStateStore = class {
     this.id = opts.identityId;
     this.cipher = opts.cipherFor(opts.identityId);
     this.memoryRetentionK = opts.memoryRetentionK ?? 500;
+    this.memoryRetentionMs = opts.memoryRetentionMs ?? DEFAULT_MEMORY_RETENTION_MS;
+    this.memoryFactRetentionK = opts.memoryFactRetentionK ?? DEFAULT_MEMORY_FACT_RETENTION_K;
+    this.memoryFactRetentionMs = opts.memoryFactRetentionMs ?? DEFAULT_MEMORY_FACT_RETENTION_MS;
+    this.memoryNow = opts.memoryNow ?? Date.now;
     try {
       this.db = new DatabaseSync(opts.dbPath);
     } catch (e) {
@@ -6056,23 +6082,24 @@ var SqliteMlsStateStore = class {
     const dedupKey = input.messageId ?? input.idempotencyKey ?? null;
     if (!dedupKey)
       throw new Error("recordMemory requires message_id or idempotency_key");
+    const now = this.memoryNow();
+    this.pruneMemory(input.conversationId, now);
     const sealed = await this.cipher.seal(new TextEncoder().encode(input.text));
     const info = this.db.prepare(`INSERT OR IGNORE INTO agent_memory
          (identity_id, conversation_id, seq, role, peer_id, sealed_text, modality, message_id, idempotency_key, dedup_key, recorded_at)
        VALUES (?, ?,
          (SELECT COALESCE(MAX(seq),0)+1 FROM agent_memory WHERE identity_id=? AND conversation_id=?),
-         ?, ?, ?, ?, ?, ?, ?, ?)`).run(this.id, input.conversationId, this.id, input.conversationId, input.role, input.peerId ?? null, sealed, input.modality, input.messageId ?? null, input.idempotencyKey ?? null, dedupKey, Date.now());
+         ?, ?, ?, ?, ?, ?, ?, ?)`).run(this.id, input.conversationId, this.id, input.conversationId, input.role, input.peerId ?? null, sealed, input.modality, input.messageId ?? null, input.idempotencyKey ?? null, dedupKey, now);
     if (info.changes === 0) {
       const row2 = this.db.prepare("SELECT seq FROM agent_memory WHERE identity_id=? AND conversation_id=? AND dedup_key=?").get(this.id, input.conversationId, dedupKey);
       return { seq: row2.seq, deduped: true };
     }
     const row = this.db.prepare("SELECT MAX(seq) AS seq FROM agent_memory WHERE identity_id=? AND conversation_id=?").get(this.id, input.conversationId);
-    if (this.memoryRetentionK > 0) {
-      this.db.prepare("DELETE FROM agent_memory WHERE identity_id=? AND conversation_id=? AND seq <= ?").run(this.id, input.conversationId, row.seq - this.memoryRetentionK);
-    }
+    this.pruneMemoryTurns(input.conversationId, now);
     return { seq: row.seq, deduped: false };
   }
   async memoryContext(conversationId, limit = 50) {
+    this.pruneMemory(conversationId, this.memoryNow());
     const rows = this.db.prepare(`SELECT seq, role, peer_id, sealed_text, recorded_at FROM agent_memory
        WHERE identity_id=? AND conversation_id=? ORDER BY seq DESC LIMIT ?`).all(this.id, conversationId, limit);
     const recent = [];
@@ -6087,9 +6114,94 @@ var SqliteMlsStateStore = class {
     return { recent, facts };
   }
   async recordMemoryFact(conversationId, fact) {
+    const now = this.memoryNow();
     const sealed = await this.cipher.seal(new TextEncoder().encode(fact));
     this.db.prepare(`INSERT INTO agent_memory_fact (identity_id, conversation_id, fact_id, sealed_fact, added_at)
-       VALUES (?, ?, (SELECT COALESCE(MAX(fact_id),0)+1 FROM agent_memory_fact WHERE identity_id=? AND conversation_id=?), ?, ?)`).run(this.id, conversationId, this.id, conversationId, sealed, Date.now());
+       VALUES (?, ?, (SELECT COALESCE(MAX(fact_id),0)+1 FROM agent_memory_fact WHERE identity_id=? AND conversation_id=?), ?, ?)`).run(this.id, conversationId, this.id, conversationId, sealed, now);
+    this.pruneMemoryFacts(conversationId, now);
+  }
+  /**
+   * Import one owner-approved legacy fact exactly once. `assignmentKey` is
+   * content-free (`source-id:line-hash`) and intentionally excludes the target
+   * channel: the same legacy fact can therefore never be replayed into a
+   * second audience. The ledger and sealed fact commit atomically.
+   */
+  async recordImportedMemoryFact(conversationId, fact, assignmentKey) {
+    if (!/^[0-9a-f]{64}:[0-9a-f]{64}$/.test(assignmentKey)) {
+      throw new Error("invalid legacy memory assignment key");
+    }
+    const existing = this.db.prepare(`SELECT conversation_id FROM agent_memory_fact_assignment
+       WHERE identity_id=? AND assignment_key=?`).get(this.id, assignmentKey);
+    if (existing) {
+      if (existing.conversation_id !== conversationId) {
+        throw new Error("legacy memory fact is already assigned to another channel");
+      }
+      return { factId: 0, deduped: true };
+    }
+    const now = this.memoryNow();
+    const sealed = await this.cipher.seal(new TextEncoder().encode(fact));
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const raced = this.db.prepare(`SELECT conversation_id FROM agent_memory_fact_assignment
+         WHERE identity_id=? AND assignment_key=?`).get(this.id, assignmentKey);
+      if (raced) {
+        if (raced.conversation_id !== conversationId) {
+          throw new Error("legacy memory fact is already assigned to another channel");
+        }
+        this.db.exec("COMMIT");
+        return { factId: 0, deduped: true };
+      }
+      const row = this.db.prepare("SELECT COALESCE(MAX(fact_id),0)+1 AS fact_id FROM agent_memory_fact WHERE identity_id=? AND conversation_id=?").get(this.id, conversationId);
+      this.db.prepare(`INSERT INTO agent_memory_fact (identity_id, conversation_id, fact_id, sealed_fact, added_at)
+         VALUES (?, ?, ?, ?, ?)`).run(this.id, conversationId, row.fact_id, sealed, now);
+      this.db.prepare(`INSERT INTO agent_memory_fact_assignment (identity_id, assignment_key, conversation_id, applied_at)
+         VALUES (?, ?, ?, ?)`).run(this.id, assignmentKey, conversationId, now);
+      this.pruneMemoryFacts(conversationId, now);
+      this.db.exec("COMMIT");
+      return { factId: row.fact_id, deduped: false };
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  /** Remove every durable turn and fact in one channel-scoped namespace. */
+  purgeMemory(conversationId) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db.prepare("DELETE FROM agent_memory WHERE identity_id=? AND conversation_id=?").run(this.id, conversationId);
+      this.db.prepare("DELETE FROM agent_memory_fact WHERE identity_id=? AND conversation_id=?").run(this.id, conversationId);
+      this.db.prepare("DELETE FROM agent_memory_fact_assignment WHERE identity_id=? AND conversation_id=?").run(this.id, conversationId);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  pruneMemory(conversationId, now) {
+    this.pruneMemoryTurns(conversationId, now);
+    this.pruneMemoryFacts(conversationId, now);
+  }
+  pruneMemoryTurns(conversationId, now) {
+    if (this.memoryRetentionMs > 0) {
+      this.db.prepare("DELETE FROM agent_memory WHERE identity_id=? AND conversation_id=? AND recorded_at < ?").run(this.id, conversationId, now - this.memoryRetentionMs);
+    }
+    if (this.memoryRetentionK > 0) {
+      const row = this.db.prepare("SELECT MAX(seq) AS seq FROM agent_memory WHERE identity_id=? AND conversation_id=?").get(this.id, conversationId);
+      if (row.seq != null) {
+        this.db.prepare("DELETE FROM agent_memory WHERE identity_id=? AND conversation_id=? AND seq <= ?").run(this.id, conversationId, row.seq - this.memoryRetentionK);
+      }
+    }
+  }
+  pruneMemoryFacts(conversationId, now) {
+    if (this.memoryFactRetentionMs > 0) {
+      this.db.prepare("DELETE FROM agent_memory_fact WHERE identity_id=? AND conversation_id=? AND added_at < ?").run(this.id, conversationId, now - this.memoryFactRetentionMs);
+    }
+    if (this.memoryFactRetentionK > 0) {
+      const row = this.db.prepare("SELECT MAX(fact_id) AS fact_id FROM agent_memory_fact WHERE identity_id=? AND conversation_id=?").get(this.id, conversationId);
+      if (row.fact_id != null) {
+        this.db.prepare("DELETE FROM agent_memory_fact WHERE identity_id=? AND conversation_id=? AND fact_id <= ?").run(this.id, conversationId, row.fact_id - this.memoryFactRetentionK);
+      }
+    }
   }
   /** @internal test-only */
   _rawMainForTest(identityId, channelId) {
@@ -7316,6 +7428,7 @@ import { createHash, randomUUID } from "node:crypto";
 import {
   chmodSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readFileSync as readFileSync5,
   renameSync,
@@ -7323,7 +7436,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { basename as basename2, join as join6 } from "node:path";
+import { basename as basename2, isAbsolute, join as join6 } from "node:path";
 var MEMORY_FILE = "MEMORY.md";
 var REAL_FS = {
   mkdir: (p, mode) => mkdirSync(p, { recursive: true, mode }),
@@ -7398,6 +7511,54 @@ function lineHash(line) {
   return createHash("sha256").update(line.trim(), "utf8").digest("hex");
 }
 var LOCAL_REPORT_FILE = "local-config.json";
+var LEGACY_MEMORY_SOURCE_MAX_BYTES = 4 * 1024 * 1024;
+var LEGACY_MEMORY_REPORT_MAX_BYTES = 4 * 1024 * 1024;
+var LEGACY_MEMORY_REPORT_MAX_SOURCES = 100;
+var LEGACY_MEMORY_FACT_MAX_BYTES = 1024;
+var LEGACY_MEMORY_FACT_DECISION_MAX = 500;
+function legacySourceId(source, bytes) {
+  return createHash("sha256").update(source.kind).update("\0").update(source.channel_id ?? "").update("\0").update(source.path).update("\0").update(bytes).digest("hex");
+}
+function localLegacySources(doc) {
+  if (!Array.isArray(doc.legacy_memory)) return [];
+  const out = [];
+  let contentBudget = LEGACY_MEMORY_REPORT_MAX_BYTES;
+  for (const raw of doc.legacy_memory) {
+    if (out.length >= LEGACY_MEMORY_REPORT_MAX_SOURCES) break;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const source = raw;
+    const kind = source.kind;
+    const path = source.path;
+    const channelId = source.channelId;
+    if (kind !== "global-memory" && kind !== "conversation-history" && kind !== "captured-memory" || typeof path !== "string" || !isAbsolute(path) || channelId !== void 0 && typeof channelId !== "string") continue;
+    try {
+      const st = lstatSync(path);
+      if (!st.isFile() || st.isSymbolicLink()) continue;
+      if (st.size <= LEGACY_MEMORY_SOURCE_MAX_BYTES && st.size > contentBudget) continue;
+      const oversize = st.size > LEGACY_MEMORY_SOURCE_MAX_BYTES;
+      const bytes = oversize ? Buffer.from(`oversize:${st.size}:${st.mtimeMs}:${st.ctimeMs}`, "utf8") : Buffer.from(readFileSync5(path));
+      if (!oversize && (bytes.byteLength > LEGACY_MEMORY_SOURCE_MAX_BYTES || bytes.byteLength > contentBudget)) {
+        continue;
+      }
+      const exportable = !oversize;
+      const candidate = {
+        id: "",
+        kind,
+        ...typeof channelId === "string" && channelId ? { channel_id: channelId } : {},
+        path,
+        content: exportable ? bytes.toString("utf8") : null,
+        bytes: exportable ? bytes.byteLength : st.size,
+        exportable
+      };
+      candidate.id = legacySourceId(candidate, bytes);
+      if (source.id !== candidate.id) continue;
+      out.push(candidate);
+      if (exportable) contentBudget -= bytes.byteLength;
+    } catch {
+    }
+  }
+  return out;
+}
 function readLocalReport(home, identityId) {
   const p = join6(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
   if (!existsSync(p)) return null;
@@ -7409,11 +7570,98 @@ function readLocalReport(home, identityId) {
   }
   if (!doc || typeof doc !== "object" || Array.isArray(doc)) return null;
   const hasSearchKey = doc.has_search_key === true;
+  const hasLlmKey = doc.has_llm_key === true;
   const raw = doc.persona;
   const persona = raw && typeof raw === "object" && !Array.isArray(raw) ? Object.fromEntries(
     Object.entries(raw).filter(([, v]) => typeof v === "string")
   ) : {};
-  return { persona, has_search_key: hasSearchKey };
+  return {
+    persona,
+    has_search_key: hasSearchKey,
+    has_llm_key: hasLlmKey,
+    legacy_memory: localLegacySources(doc).map(({ path: _path, ...source }) => source)
+  };
+}
+function deleteLegacyMemorySources(home, identityId, ids) {
+  if (ids.length === 0) return 0;
+  const p = join6(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
+  if (!existsSync(p)) return 0;
+  let doc;
+  try {
+    doc = JSON.parse(readFileSync5(p, "utf8"));
+  } catch {
+    return 0;
+  }
+  const wanted = new Set(ids);
+  let deleted = 0;
+  for (const source of localLegacySources(doc)) {
+    if (!wanted.has(source.id)) continue;
+    try {
+      unlinkSync(source.path);
+      deleted += 1;
+    } catch {
+    }
+  }
+  return deleted;
+}
+async function applyLegacyMemoryFactDecisions(home, identityId, rawDecisions, recordFact) {
+  if (!Array.isArray(rawDecisions) || rawDecisions.length > LEGACY_MEMORY_FACT_DECISION_MAX) {
+    return { sourcesDeleted: 0, factsAssigned: 0 };
+  }
+  const bySource = /* @__PURE__ */ new Map();
+  for (const raw of rawDecisions) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      return { sourcesDeleted: 0, factsAssigned: 0 };
+    }
+    const d = raw;
+    if (typeof d.source_id !== "string" || !/^[0-9a-f]{64}$/.test(d.source_id) || typeof d.fact_hash !== "string" || !/^[0-9a-f]{64}$/.test(d.fact_hash) || d.action !== "assign" && d.action !== "delete" || d.action === "assign" && (typeof d.channel_id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(d.channel_id)) || d.action === "delete" && d.channel_id !== void 0) return { sourcesDeleted: 0, factsAssigned: 0 };
+    const decision = d;
+    const current = bySource.get(decision.source_id);
+    if (current === null) continue;
+    const group = current ?? /* @__PURE__ */ new Map();
+    const prior = group.get(decision.fact_hash);
+    if (prior && (prior.action !== decision.action || prior.channel_id !== decision.channel_id)) {
+      bySource.set(decision.source_id, null);
+      continue;
+    }
+    group.set(decision.fact_hash, decision);
+    bySource.set(decision.source_id, group);
+  }
+  const reportPath = join6(runtimeConfigDir(home, identityId), LOCAL_REPORT_FILE);
+  if (!existsSync(reportPath)) return { sourcesDeleted: 0, factsAssigned: 0 };
+  let doc;
+  try {
+    doc = JSON.parse(readFileSync5(reportPath, "utf8"));
+  } catch {
+    return { sourcesDeleted: 0, factsAssigned: 0 };
+  }
+  let sourcesDeleted = 0;
+  let factsAssigned = 0;
+  for (const source of localLegacySources(doc)) {
+    const decisions = bySource.get(source.id);
+    if (!decisions || source.kind !== "global-memory" || source.content === null) continue;
+    const facts = source.content.split("\n").map((line) => line.trim()).filter(Boolean);
+    const currentHashes = new Set(facts.map(lineHash));
+    if (currentHashes.size === 0 || decisions.size !== currentHashes.size || [...currentHashes].some((hash) => !decisions.has(hash)) || [...decisions].some(([hash]) => !currentHashes.has(hash))) continue;
+    const uniqueFacts = /* @__PURE__ */ new Map();
+    for (const fact of facts) uniqueFacts.set(lineHash(fact), fact);
+    const assignments = [...decisions].filter(([, decision]) => decision.action === "assign");
+    if (assignments.some(([hash]) => Buffer.byteLength(uniqueFacts.get(hash) ?? "", "utf8") > LEGACY_MEMORY_FACT_MAX_BYTES)) {
+      continue;
+    }
+    try {
+      for (const [hash, decision] of assignments) {
+        await recordFact(decision.channel_id, uniqueFacts.get(hash), `${source.id}:${hash}`);
+        factsAssigned += 1;
+      }
+      const stillCurrent = localLegacySources(doc).some((candidate) => candidate.id === source.id);
+      if (!stillCurrent) continue;
+      unlinkSync(source.path);
+      sourcesDeleted += 1;
+    } catch {
+    }
+  }
+  return { sourcesDeleted, factsAssigned };
 }
 function readManagedMemory(home, identityId) {
   const p = join6(runtimeConfigDir(home, identityId), MEMORY_FILE);
@@ -7442,6 +7690,51 @@ function pruneManagedMemory(home, identityId, hashes, deps = REAL_FS) {
 
 // src/bridge-agent.ts
 import { homedir as homedir2 } from "node:os";
+
+// src/reply-receipts.ts
+var DEFAULT_TTL_MS = 15 * 60 * 1e3;
+var DEFAULT_CAPACITY2 = 256;
+var RuntimeReplyReceiptLedger = class {
+  receipts = /* @__PURE__ */ new Map();
+  ttlMs;
+  capacity;
+  now;
+  constructor(opts = {}) {
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.capacity = opts.capacity ?? DEFAULT_CAPACITY2;
+    this.now = opts.now ?? Date.now;
+    if (!Number.isFinite(this.ttlMs) || this.ttlMs <= 0) throw new Error("reply receipt ttlMs must be positive");
+    if (!Number.isInteger(this.capacity) || this.capacity <= 0) throw new Error("reply receipt capacity must be positive");
+  }
+  record(inReplyTo, channelId, replyMessageId) {
+    const receipt = Object.freeze({
+      in_reply_to: inReplyTo,
+      reply_message_id: replyMessageId,
+      channel_id: channelId,
+      replied_at: this.now()
+    });
+    this.prune(receipt.replied_at);
+    this.receipts.delete(inReplyTo);
+    this.receipts.set(inReplyTo, receipt);
+    while (this.receipts.size > this.capacity) {
+      const oldest = this.receipts.keys().next().value;
+      if (oldest === void 0) break;
+      this.receipts.delete(oldest);
+    }
+    return receipt;
+  }
+  get(inReplyTo) {
+    this.prune(this.now());
+    return this.receipts.get(inReplyTo) ?? null;
+  }
+  prune(now) {
+    for (const [key, receipt] of this.receipts) {
+      if (now - receipt.replied_at >= this.ttlMs) this.receipts.delete(key);
+    }
+  }
+};
+
+// src/bridge-agent.ts
 var VOICE_MODE_GUIDANCE = "Reply immediately and conversationally, one short sentence per message; never bundle multiple points into one message.";
 var FAST_PATH_SPOKEN_GUIDANCE = "A one-sentence spoken acknowledgement has already been sent for this turn. Reply only with information it did not contain, in one or two short sentences; if there is nothing to add, send nothing.";
 var ROOM_VOICE_GUIDANCE_MENTION_ONLY = "You are in a group voice room. Reply ONLY when a message @mentions your display name. Keep replies to one short sentence. When you should not reply, send nothing.";
@@ -7711,6 +8004,12 @@ var BridgeAgent = class _BridgeAgent {
   channelOwner = /* @__PURE__ */ new Map();
   buffer = [];
   maxBuffer;
+  /**
+   * Short-lived, content-free runtime reply correlations. The attached runtime
+   * supplies the inbound message id only when an outbound send is its reply;
+   * ws-server/http-server record the receipt after send() publishes.
+   */
+  runtimeReplyReceipts = new RuntimeReplyReceiptLedger();
   /** Cumulative count of messages shed by the buffer cap (surfaced on health()/metrics()). */
   droppedMessages = 0;
   /**
@@ -7936,6 +8235,7 @@ var BridgeAgent = class _BridgeAgent {
   waiters = [];
   pingHandle;
   safetyTimer;
+  runtimeConfigTimer;
   listeners = /* @__PURE__ */ new Set();
   startedAt = 0;
   store;
@@ -8045,25 +8345,65 @@ var BridgeAgent = class _BridgeAgent {
       });
       if (!res.ok) throw new Error(`runtime-config ${res.status}`);
       const payload = await res.json();
-      if (!payload || !payload.version) {
+      if (!payload) {
+        process.stderr.write("[bridge] runtime config not applied (empty response)\n");
+        return;
+      }
+      if (typeof payload.version !== "number") {
         process.stderr.write(
-          `[bridge] runtime config not applied (version ${JSON.stringify(payload?.version ?? null)} \u2014 no saved config)
+          `[bridge] runtime config not applied (version ${JSON.stringify(payload.version ?? null)} \u2014 invalid response)
 `
         );
         return;
       }
+      const version = payload.version;
+      if (!version) {
+        writeManagedFiles(this.home, this.cfg.identityId, {});
+        process.stderr.write(
+          `[bridge] runtime config not applied (version ${JSON.stringify(payload?.version ?? null)} \u2014 no saved config)
+`
+        );
+      }
       const skillsJson = payload.skills_json ?? {};
-      writeManagedFiles(this.home, this.cfg.identityId, {
-        ...payload.files ?? {},
-        "skills.json": `${JSON.stringify(skillsJson, null, 2)}
+      if (version) {
+        writeManagedFiles(this.home, this.cfg.identityId, {
+          ...payload.files ?? {},
+          "skills.json": `${JSON.stringify(skillsJson, null, 2)}
 `
-      });
+        });
+      }
       if (payload.memory_prunes?.length) {
         pruneManagedMemory(this.home, this.cfg.identityId, payload.memory_prunes);
       }
+      if (payload.legacy_memory_deletes?.length) {
+        deleteLegacyMemorySources(this.home, this.cfg.identityId, payload.legacy_memory_deletes);
+      }
+      if (payload.legacy_memory_fact_decisions?.length) {
+        const provider = this.cfg.memoryProvider ?? "securecoms";
+        const result = await applyLegacyMemoryFactDecisions(
+          this.home,
+          this.cfg.identityId,
+          payload.legacy_memory_fact_decisions,
+          async (channelId, fact, assignmentKey) => {
+            if (provider === "none" || provider === "hermes") {
+              throw new Error("configured memory provider has no protected channel-fact import path");
+            }
+            if (provider === "openclaw" && !await this.mayReadOpenClawMemory(channelId)) {
+              throw new Error("OpenClaw legacy fact target is not the active owner DM");
+            }
+            await this.store.recordImportedMemoryFact(channelId, fact, assignmentKey);
+          }
+        );
+        if (result.sourcesDeleted > 0) {
+          process.stderr.write(
+            `[bridge] legacy-memory disposition applied (sources=${result.sourcesDeleted}, assigned=${result.factsAssigned})
+`
+          );
+        }
+      }
       const local = readLocalReport(this.home, this.cfg.identityId);
       const report = {
-        applied_version: payload.version,
+        applied_version: version,
         paths: checkConfiguredPaths(skillsJson),
         // Read AFTER the prunes above, so the owner's next view of memory is
         // the file as it now stands, not the one they just pruned from.
@@ -8075,7 +8415,18 @@ var BridgeAgent = class _BridgeAgent {
         // is an environment value on that process, invisible to the daemon and
         // to the backend. The backend needs it to generate a truthful tool
         // paragraph, so it rides along here.
-        has_search_key: local?.has_search_key ?? false
+        has_search_key: local?.has_search_key ?? false,
+        // Same idea, for the BYOK LLM key file: only the runtime can see
+        // whether one is configured in its own environment.
+        has_llm_key: local?.has_llm_key ?? false,
+        // The backend uses this only to expose target channels compatible with
+        // the actual protected-memory adapter. It is an enum, never a path or
+        // provider credential.
+        memory_provider: this.cfg.memoryProvider ?? "securecoms",
+        // Inert legacy files only. `readLocalReport` revalidates the current
+        // regular-file bytes and strips every local path before this leaves the
+        // machine.
+        legacy_memory: local?.legacy_memory ?? []
       };
       const posted = await this.fetchImpl(`${base}/report`, {
         method: "POST",
@@ -8087,13 +8438,16 @@ var BridgeAgent = class _BridgeAgent {
       });
       if (!posted.ok) {
         process.stderr.write(
-          `[bridge] runtime config v${payload.version} written, but reporting it failed (${posted.status}) \u2014 the console will keep showing it as not applied until the next cycle
+          version ? `[bridge] runtime config v${version} written, but reporting it failed (${posted.status}) \u2014 the console will keep showing it as not applied until the next cycle
+` : `[bridge] legacy-memory inventory report failed (${posted.status}); no saved runtime config was applied
 `
         );
         return;
       }
-      process.stderr.write(`[bridge] runtime config v${payload.version} applied
-`);
+      process.stderr.write(
+        version ? `[bridge] runtime config v${version} applied
+` : "[bridge] legacy-memory inventory reported; no saved runtime config was applied\n"
+      );
     } catch (e) {
       process.stderr.write(
         `[bridge] runtime config refetch failed: ${e?.message ?? e}
@@ -8129,6 +8483,10 @@ var BridgeAgent = class _BridgeAgent {
     await this.provider.publishKeyPackage();
     await this.refetchVoiceSettings();
     await this.refetchRuntimeConfig();
+    this.runtimeConfigTimer = setInterval(() => {
+      void this.refetchRuntimeConfig();
+    }, 6 * 60 * 60 * 1e3);
+    this.runtimeConfigTimer.unref?.();
     this.startReceivePump();
     if (this.selfHealSweepEnabled) {
       this.bootSweepTimer = setTimeout(
@@ -8931,7 +9289,47 @@ var BridgeAgent = class _BridgeAgent {
   async recordMemory(input) {
     return this.memory.record(input);
   }
+  /**
+   * OpenClaw collapses text history and workspace facts into the owner's
+   * session. Resolve the channel from fresh, authenticated server metadata
+   * before exposing that provider through the local bridge API. A cold or
+   * stale cache is refreshed once; any failure remains a fail-closed denial.
+   */
+  async mayReadOpenClawMemory(channelId) {
+    if (this.cfg.memoryProvider !== "openclaw") return true;
+    if (!this.freshMeta(channelId)) await this.refreshChannelMeta();
+    if (!this.freshRoster(channelId)) await this.refreshChannelRoster(channelId);
+    const meta = this.freshMeta(channelId);
+    const roster = this.freshRoster(channelId);
+    if (meta?.is_dm !== true || !roster) return false;
+    const humanCounterparts = [...roster.entries()].filter(
+      ([identityId, member]) => identityId !== this.cfg.identityId && !member.is_agent
+    );
+    return humanCounterparts.length === 1 && humanCounterparts[0][1].is_agent_owner;
+  }
+  /** An inbound turn may receive OpenClaw memory only from an active owner DM. */
+  mayReadOpenClawMemoryForTurn(authorization) {
+    return this.cfg.memoryProvider !== "openclaw" || authorization.sender_membership === "active" && authorization.audience === "owner_dm";
+  }
+  /**
+   * Resolve the prior-turn snapshot carried to the native runtime. OpenClaw
+   * stays owner-DM-only; every provider failure degrades to empty context and
+   * never falls back to the runtime's retired plaintext JSON files.
+   */
+  async memoryForTurn(channelId, authorization, limit = 50) {
+    if (!this.mayReadOpenClawMemoryForTurn(authorization)) {
+      return { recent: [], facts: [] };
+    }
+    try {
+      return await this.memory.context(channelId, limit);
+    } catch {
+      return { recent: [], facts: [] };
+    }
+  }
   async memoryContext(conversationId, limit) {
+    if (!await this.mayReadOpenClawMemory(conversationId)) {
+      return { recent: [], facts: [] };
+    }
     return this.memory.context(conversationId, limit);
   }
   /**
@@ -8975,10 +9373,14 @@ var BridgeAgent = class _BridgeAgent {
     }
     try {
       let memory;
-      try {
-        memory = await this.memory.context(m.channelId, 30);
-      } catch {
+      if (!this.mayReadOpenClawMemoryForTurn(m.authorization)) {
         memory = { recent: [], facts: [] };
+      } else {
+        try {
+          memory = await this.memory.context(m.channelId, 30);
+        } catch {
+          memory = { recent: [], facts: [] };
+        }
       }
       const messages = buildFastMessages({
         persona: this.cfg.voice.persona,
@@ -9231,13 +9633,42 @@ var BridgeAgent = class _BridgeAgent {
       const rows = await res.json();
       const members = /* @__PURE__ */ new Map();
       for (const r of rows) {
-        members.set(r.identity_id, { name: r.display_name, is_agent: r.is_agent });
+        members.set(r.identity_id, {
+          name: r.display_name,
+          is_agent: r.is_agent,
+          is_agent_owner: r.is_agent_owner === true,
+          is_partner: r.is_partner === true
+        });
       }
       this.channelRoster.set(channelId, { members, at: Date.now() });
       await this.resolveAndPinOwner(channelId, rows);
     } catch {
     }
   }
+  /**
+   * Classify the sender only from server-authenticated channel/roster data.
+   * Missing or stale metadata is UNKNOWN with zero grants, never a permissive
+   * guess. The returned object and grant array are frozen before they cross the
+   * daemon boundary so one consumer cannot widen a later execution check.
+   */
+  authorizationFor(channelId, senderId) {
+    const meta = this.freshMeta(channelId);
+    const sender = this.freshRoster(channelId)?.get(senderId);
+    let audience = "unknown";
+    if (meta && sender) {
+      if (sender.is_agent) audience = "agent_to_agent";
+      else if (meta.is_dm && sender.is_agent_owner) audience = "owner_dm";
+      else if (meta.is_dm) audience = "other_human_dm";
+      else if (sender.is_partner) audience = "partner_room";
+      else audience = "team_room";
+    }
+    return Object.freeze({
+      version: 1,
+      audience,
+      sender_membership: sender ? "active" : "unknown",
+      tool_grants: Object.freeze([])
+    });
+  }
   /**
    * Task 8 (owner-attested Reset Secure Session): STRUCTURAL owner selection —
    * NEVER read the server's `role` field to pick the owner. In a DM the owner
@@ -9751,6 +10182,7 @@ var BridgeAgent = class _BridgeAgent {
                 sender_id: m.envelope.sender_id,
                 text: typeof parsed.text === "string" ? parsed.text : "",
                 ts: m.receivedAt,
+                authorization: this.authorizationFor(m.channelId, m.envelope.sender_id),
                 sender_name: senderName,
                 sender_is_agent: senderIsAgent,
                 attachments: [attachment],
@@ -9789,6 +10221,11 @@ var BridgeAgent = class _BridgeAgent {
             const senderName = this.freshRoster(m.channelId)?.get(
               m.envelope.sender_id
             )?.name;
+            const turnAuthorization = this.authorizationFor(
+              m.channelId,
+              m.envelope.sender_id
+            );
+            const runtimeMemory = this.memoryForTurn(m.channelId, turnAuthorization);
             const speaker = parsed.relay === true && typeof parsed.speaker_identity_id === "string" && typeof parsed.speaker_display_name === "string" ? {
               identityId: parsed.speaker_identity_id,
               displayName: parsed.speaker_display_name
@@ -9805,12 +10242,14 @@ var BridgeAgent = class _BridgeAgent {
             const turnText = parsed.text;
             const isCallStart = turnText.trim() === VOICE_CALL_START_MARKER;
             const fastGreeting = isCallStart && fastPathFiring;
-            const runtimeEntry = (ackSent) => ({
+            const runtimeEntry = (ackSent, memory) => ({
               channel_id: m.channelId,
               message_id: m.messageId,
               sender_id: m.envelope.sender_id,
               text: turnText,
               ts: m.receivedAt,
+              authorization: turnAuthorization,
+              memory,
               // A relay-attributed turn is the SPEAKER's message to the runtime:
               // name it after them and never flag it as agent-authored.
               sender_name: speaker?.displayName ?? senderName,
@@ -9824,18 +10263,23 @@ var BridgeAgent = class _BridgeAgent {
             if (fastPathFiring) {
               const fastSpeaker = speaker ?? (senderName ? { identityId: m.envelope.sender_id, displayName: senderName } : void 0);
               void this.runFastPath(
-                { channelId: m.channelId, messageId: m.messageId, senderId: m.envelope.sender_id },
+                {
+                  channelId: m.channelId,
+                  messageId: m.messageId,
+                  senderId: m.envelope.sender_id,
+                  authorization: turnAuthorization
+                },
                 fastGreeting ? greetingTurnFor(this.voiceSettings ?? DEFAULT_VOICE_SETTINGS, fastSpeaker?.displayName) : parsed.text,
                 voiceGuidance,
                 fastSpeaker
-              ).then((outcome) => {
+              ).then(async (outcome) => {
                 if (outcome === "answered") return;
-                this.buffer.push(runtimeEntry(outcome === "deferred"));
+                this.buffer.push(runtimeEntry(outcome === "deferred", await runtimeMemory));
                 this.capBuffer();
                 this.wakeListeners();
               });
             } else {
-              this.buffer.push(runtimeEntry(false));
+              this.buffer.push(runtimeEntry(false, await runtimeMemory));
             }
             this.capBuffer();
             void recordInboundMemory(
@@ -9901,6 +10345,12 @@ var BridgeAgent = class _BridgeAgent {
     this.buffer.push(...keep);
     return out;
   }
+  recordRuntimeReply(inReplyTo, channelId, replyMessageId) {
+    return this.runtimeReplyReceipts.record(inReplyTo, channelId, replyMessageId);
+  }
+  runtimeReplyReceipt(inReplyTo) {
+    return this.runtimeReplyReceipts.get(inReplyTo);
+  }
   /**
    * Put messages back at the front (SSE/disconnect write-failure recovery).
    *
@@ -10052,6 +10502,7 @@ var BridgeAgent = class _BridgeAgent {
     this.closingDown = true;
     this.pingHandle?.close();
     if (this.safetyTimer) clearInterval(this.safetyTimer);
+    if (this.runtimeConfigTimer) clearInterval(this.runtimeConfigTimer);
     if (this.bootSweepTimer) clearTimeout(this.bootSweepTimer);
     if (this.selfHealTimer) clearTimeout(this.selfHealTimer);
     await this.provider.drainInFlight(_BridgeAgent.GRACEFUL_DRAIN_MS);
@@ -10285,6 +10736,7 @@ var sendSchema = z3.object({
   channel_id: z3.string().min(1),
   text: z3.string().optional(),
   idempotency_key: z3.string().optional(),
+  in_reply_to: z3.string().min(1).max(200).optional(),
   a2a: a2aSchema.optional()
 }).refine((d) => typeof d.text === "string" || d.a2a !== void 0, {
   message: "send requires either text or a2a"
@@ -10401,10 +10853,19 @@ function createHttpServer(agent, opts) {
       if (method === "GET" && path === "/v1/metrics") {
         return json(res, 200, agent.metrics());
       }
+      if (method === "GET" && path === "/v1/reply-receipt") {
+        const inReplyTo = url.searchParams.get("in_reply_to");
+        if (!inReplyTo || inReplyTo.length > 200) return jsonError(res, "invalid_request");
+        const receipt = agent.runtimeReplyReceipt(inReplyTo);
+        return json(res, 200, receipt ? { found: true, receipt } : { found: false });
+      }
       if (method === "POST" && path === "/v1/send") {
         const parsed = sendSchema.safeParse(JSON.parse(await readBody(req, SEND_CAP)));
         if (!parsed.success) return jsonError(res, "invalid_request", parsed.error.issues);
         const r = parsed.data.a2a ? await agent.sendA2A(parsed.data.channel_id, parsed.data.a2a) : await agent.send(parsed.data.channel_id, parsed.data.text);
+        if (parsed.data.in_reply_to) {
+          agent.recordRuntimeReply(parsed.data.in_reply_to, parsed.data.channel_id, r.message_id);
+        }
         return json(res, 200, r);
       }
       if (method === "POST" && path === "/v1/send-attachment") {
@@ -10660,6 +11121,10 @@ async function handleInbound(sock, agent, data, inflight) {
       sendJson(sock, wsErrorFrame("invalid_request"));
       return;
     }
+    if (m.in_reply_to !== void 0 && (typeof m.in_reply_to !== "string" || m.in_reply_to.length === 0 || m.in_reply_to.length > 200)) {
+      sendJson(sock, wsErrorFrame("invalid_request"));
+      return;
+    }
     if (m.a2a && typeof m.a2a === "object") {
       const a = m.a2a;
       if (typeof a.a2a_version !== "string" || !a.a2a_version || a.kind !== "message" && a.kind !== "task" && a.kind !== "artifact" || typeof a.object !== "object" || a.object === null) {
@@ -10668,6 +11133,9 @@ async function handleInbound(sock, agent, data, inflight) {
       }
       try {
         const r = await agent.sendA2A(m.channel_id, { a2a_version: a.a2a_version, kind: a.kind, object: a.object });
+        if (typeof m.in_reply_to === "string") {
+          agent.recordRuntimeReply(m.in_reply_to, m.channel_id, r.message_id);
+        }
         sendJson(sock, { type: "sent", message_id: r.message_id });
       } catch (e) {
         if (e instanceof ChannelPendingError) {
@@ -10686,6 +11154,9 @@ async function handleInbound(sock, agent, data, inflight) {
     }
     try {
       const r = await agent.send(m.channel_id, m.text);
+      if (typeof m.in_reply_to === "string") {
+        agent.recordRuntimeReply(m.in_reply_to, m.channel_id, r.message_id);
+      }
       sendJson(sock, { type: "sent", message_id: r.message_id });
     } catch (e) {
       if (e instanceof ChannelPendingError) {