@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/lib/adapters/wechat/key-providers/frida-key-provider.js

@@ -0,0 +1,252 @@
+/**
+ * Phase 12.6.3 — FridaKeyProvider (v1 hot path).
+ *
+ * Attaches frida to a live WeChat process (com.tencent.mm) on a rooted
+ * Android device, injects the wechat-key-hook agent (see
+ * frida-agent/wechat-key-hook.js), waits for the first sqlite3_key
+ * onEnter, captures the 32-byte hex key, then detaches.
+ *
+ * Why detach immediately:
+ *   §18.6 anti-detection — minimize injection window so WeChat's
+ *   ptrace-tracer / mem-scanner doesn't catch frida-gum sitting in
+ *   the process. We hold the script alive only as long as it takes
+ *   the user to touch a chat thread (typically 1-3s).
+ *
+ * Wire to KeyProvider:
+ *   getKey() resolves with lowercase 64-char hex on success, or
+ *   rejects with one of the typed error codes:
+ *     - FRIDA_BINDING_MISSING : opts.frida not provided and require()
+ *                               of "frida" failed (binding not installed)
+ *     - WECHAT_NOT_RUNNING    : device.attach() threw on package name
+ *     - FRIDA_ATTACH_FAILED   : any other attach/createScript error
+ *     - HOOK_FAILED           : agent reported error event before key
+ *     - WCDB_KEY_TIMEOUT      : no key event within timeoutMs
+ *
+ * Test seam: opts.frida overrides the lazy require("frida"), so unit
+ * tests inject a mock device manager without touching the real binding.
+ */
+"use strict";
+
+const { KeyProvider } = require("./key-provider-base");
+const { loadAgentScript } = require("../frida-agent/loader");
+
+class FridaKeyProvider extends KeyProvider {
+  /**
+   * @param {object} opts
+   * @param {object} [opts.frida]       injected nodejs binding (test seam);
+   *                                    if absent, lazy require("frida")
+   * @param {string} [opts.deviceId]    Frida device id (USB device default
+   *                                    if omitted; "local" for Wear/host)
+   * @param {string} [opts.packageName="com.tencent.mm"]
+   * @param {number} [opts.timeoutMs=30000]
+   * @param {Function} [opts.agentLoader]  test seam: returns agent script
+   *                                       text; defaults to loadAgentScript
+   * @param {Function} [opts.logger]    optional log({level, ...evt})
+   */
+  constructor(opts = {}) {
+    super();
+    if (!opts || typeof opts !== "object") {
+      throw new Error("FridaKeyProvider: opts required");
+    }
+    this._fridaInjected = opts.frida || null;
+    this._deviceId = opts.deviceId || null;
+    this._packageName = opts.packageName || "com.tencent.mm";
+    this._timeoutMs = Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0
+      ? opts.timeoutMs
+      : 30_000;
+    this._agentLoader = typeof opts.agentLoader === "function"
+      ? opts.agentLoader
+      : loadAgentScript;
+    this._logger = typeof opts.logger === "function" ? opts.logger : null;
+    this._lastTelemetry = null;
+  }
+
+  get name() {
+    return "frida";
+  }
+
+  getLastTelemetry() {
+    return this._lastTelemetry;
+  }
+
+  _log(evt) {
+    if (this._logger) {
+      try { this._logger(evt); } catch (_e) { /* swallow logger faults */ }
+    }
+  }
+
+  _loadFrida() {
+    if (this._fridaInjected) return this._fridaInjected;
+    try {
+      // eslint-disable-next-line global-require
+      return require("frida");
+    } catch (err) {
+      const e = new Error(
+        "FridaKeyProvider: frida nodejs binding not installed. " +
+        "Install with `npm install frida` on the host, or pass opts.frida. " +
+        "Underlying error: " + (err && err.message ? err.message : String(err))
+      );
+      e.code = "FRIDA_BINDING_MISSING";
+      throw e;
+    }
+  }
+
+  async _getDevice(frida) {
+    if (this._deviceId) {
+      const dev = await frida.getDevice(this._deviceId);
+      return dev;
+    }
+    // No id → first USB device
+    if (typeof frida.getUsbDevice === "function") {
+      return await frida.getUsbDevice();
+    }
+    return await frida.getDeviceManager().getUsbDevice();
+  }
+
+  /**
+   * @returns {Promise<string>} 64-char lowercase hex SQLCipher key
+   */
+  async getKey(_callOpts) {
+    const telemetry = {
+      startedAt: Date.now(),
+      packageName: this._packageName,
+      deviceId: this._deviceId,
+      hooked: [],
+      errors: [],
+      keySource: null,
+      durationMs: null,
+    };
+
+    const frida = this._loadFrida();
+    let device, session, script;
+
+    try {
+      device = await this._getDevice(frida);
+    } catch (err) {
+      const e = new Error(
+        "FridaKeyProvider: failed to acquire Frida device" +
+        (this._deviceId ? ` (${this._deviceId})` : "") +
+        ": " + (err && err.message ? err.message : String(err))
+      );
+      e.code = "FRIDA_ATTACH_FAILED";
+      this._lastTelemetry = telemetry;
+      throw e;
+    }
+
+    try {
+      session = await device.attach(this._packageName);
+    } catch (err) {
+      const errMsg = err && err.message ? err.message : String(err);
+      const e = new Error(
+        `FridaKeyProvider: device.attach(${this._packageName}) failed: ${errMsg}`
+      );
+      // Distinguish "process not found" vs other attach errors
+      e.code = /unable to find process|process not found/i.test(errMsg)
+        ? "WECHAT_NOT_RUNNING"
+        : "FRIDA_ATTACH_FAILED";
+      this._lastTelemetry = telemetry;
+      throw e;
+    }
+
+    try {
+      const agentSrc = this._agentLoader();
+      script = await session.createScript(agentSrc);
+    } catch (err) {
+      const e = new Error(
+        "FridaKeyProvider: createScript failed: " +
+        (err && err.message ? err.message : String(err))
+      );
+      e.code = "FRIDA_ATTACH_FAILED";
+      this._lastTelemetry = telemetry;
+      // Clean up the session before throwing
+      try { await session.detach(); } catch (_e) {}
+      throw e;
+    }
+
+    // Promise resolves on the first 'key' message; rejects on the first
+    // 'error' (after script load) or after timeoutMs without key.
+    const keyHex = await new Promise((resolve, reject) => {
+      let settled = false;
+      let timer = null;
+
+      const cleanup = async () => {
+        if (timer) { clearTimeout(timer); timer = null; }
+        try { await script.unload(); } catch (_e) {}
+        try { await session.detach(); } catch (_e) {}
+      };
+
+      const onMessage = (message, _data) => {
+        if (settled) return;
+        if (!message || message.type !== "send" || !message.payload) return;
+        const evt = message.payload;
+        this._log({ level: "info", kind: "frida-message", evt });
+
+        if (evt.kind === "hooked") {
+          telemetry.hooked.push({ symbol: evt.symbol, module: evt.module });
+          return;
+        }
+        if (evt.kind === "module-waiting") {
+          return; // informational
+        }
+        if (evt.kind === "key") {
+          settled = true;
+          telemetry.keySource = evt.source;
+          // Phase 12.6 (post-sjqz audit) — capture sig/format/length so a
+          // failed DB open can be diagnosed: ascii-hex vs raw-bytes
+          // determines whether sqlite3_key got the expected key bytes,
+          // and sig=v1/v2 confirms args index resolution.
+          telemetry.keyFormat = evt.format || null;
+          telemetry.keySig = evt.sig || null;
+          telemetry.keyLength = evt.length || null;
+          telemetry.keyAlt = evt.alt || null;
+          telemetry.durationMs = Date.now() - telemetry.startedAt;
+          cleanup().then(() => resolve(String(evt.hex || "").toLowerCase()));
+          return;
+        }
+        if (evt.kind === "error") {
+          telemetry.errors.push(evt.message);
+          // Don't reject on individual hook errors; we may still get a
+          // key from a fallback symbol. Only reject on timeout.
+          return;
+        }
+      };
+
+      script.message.connect(onMessage);
+
+      script.load().catch((err) => {
+        if (settled) return;
+        settled = true;
+        cleanup().then(() => {
+          const e = new Error(
+            "FridaKeyProvider: script.load failed: " +
+            (err && err.message ? err.message : String(err))
+          );
+          e.code = "FRIDA_ATTACH_FAILED";
+          reject(e);
+        });
+      });
+
+      timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        cleanup().then(() => {
+          const last = telemetry.errors.length > 0
+            ? ` (last hook error: ${telemetry.errors[telemetry.errors.length - 1]})`
+            : "";
+          const e = new Error(
+            `FridaKeyProvider: no sqlite3_key call within ${this._timeoutMs}ms` +
+            (telemetry.hooked.length === 0 ? " — libwcdb.so never loaded; " +
+              "did the user touch a chat thread?" : "") + last
+          );
+          e.code = "WCDB_KEY_TIMEOUT";
+          reject(e);
+        });
+      }, this._timeoutMs);
+    });
+
+    this._lastTelemetry = telemetry;
+    return keyHex;
+  }
+}
+
+module.exports = { FridaKeyProvider };

package/lib/adapters/wechat/key-providers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const { KeyProvider } = require("./key-provider-base");
+const { MD5KeyProvider } = require("./md5-key-provider");
+
+// FridaKeyProvider depends on the optional `frida` nodejs binding. Load
+// lazily so users on devices without the binding can still use the v0.5
+// MD5 path. Phase 12.6.3 ships the implementation.
+let FridaKeyProvider = null;
+try {
+  // eslint-disable-next-line global-require
+  ({ FridaKeyProvider } = require("./frida-key-provider"));
+} catch (_e) {
+  // Module not yet built / frida binding missing — leave null. Callers
+  // that need it should require it directly so they see the real error.
+}
+
+module.exports = {
+  KeyProvider,
+  MD5KeyProvider,
+  FridaKeyProvider,
+};

package/lib/adapters/wechat/key-providers/key-provider-base.js

@@ -0,0 +1,44 @@
+/**
+ * Phase 12.6 — KeyProvider interface contract.
+ *
+ * The wechat-adapter is key-source agnostic: it only knows about an
+ * object with `getKey()` returning a Promise<string> (32-hex SQLCipher
+ * key for v0.5 7-char prefix, or full 64-hex for Frida hot path).
+ *
+ * Two implementations:
+ *   - MD5KeyProvider (v0.5, frida-INDEPENDENT) — derives MD5(IMEI+UIN)[:7]
+ *     from on-disk WeChat data dir. Works for WeChat < 8.0.x.
+ *   - FridaKeyProvider (v1, frida-DEPENDENT)  — attaches frida to live
+ *     WeChat process and hooks sqlite3_key. Works for WeChat 8.0+.
+ *
+ * Both expose the same getKey() shape so wechat-adapter.js does not
+ * branch on version.
+ */
+"use strict";
+
+class KeyProvider {
+  /**
+   * Return the SQLCipher key (lowercase hex). Throw on failure.
+   *
+   * Optional opts (per design §18.2):
+   *   - wxid : string  WeChat user identifier (some providers need this)
+   *   - dbPath : string path to the SQLCipher DB being opened
+   *
+   * @param {{wxid?: string, dbPath?: string}} [_opts]
+   * @returns {Promise<string>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  async getKey(_opts) {
+    throw new Error("KeyProvider.getKey: must be overridden by subclass");
+  }
+
+  /**
+   * Provider name for telemetry / error attribution. Subclasses
+   * override.
+   */
+  get name() {
+    return "key-provider-base";
+  }
+}
+
+module.exports = { KeyProvider };

package/lib/adapters/wechat/key-providers/md5-key-provider.js

@@ -0,0 +1,81 @@
+/**
+ * Phase 12.6.1 — MD5KeyProvider (v0.5 legacy WeChat < 8.0 path).
+ *
+ * Wraps the existing key-extractor.js (MD5(IMEI+UIN)[:7] lowercase)
+ * behind the KeyProvider interface. Pure frida-independent: works from
+ * a pulled WeChat data directory (`adb pull /data/data/com.tencent.mm/`).
+ *
+ * Usage:
+ *   const provider = new MD5KeyProvider({
+ *     wechatDataPath: "/tmp/com.tencent.mm",
+ *     // optional manual overrides for testing or when CompatibleInfo.cfg
+ *     // parsing fails
+ *     uin: "1234567890",
+ *     imei: "1234567890abcdef",
+ *   });
+ *   const key = await provider.getKey();
+ */
+"use strict";
+
+const { KeyProvider } = require("./key-provider-base");
+const { extractWeChatKey } = require("../key-extractor");
+
+class MD5KeyProvider extends KeyProvider {
+  /**
+   * @param {object} opts
+   * @param {string} opts.wechatDataPath  directory mirroring the pulled
+   *                                       /data/data/com.tencent.mm/ tree
+   * @param {string} [opts.uin]            override (skip auth XML parse)
+   * @param {string} [opts.imei]           override (skip CompatibleInfo)
+   * @param {Function} [opts.extractor]    DI seam — defaults to
+   *                                       extractWeChatKey
+   */
+  constructor(opts = {}) {
+    super();
+    if (!opts || typeof opts !== "object") {
+      throw new Error("MD5KeyProvider: opts required");
+    }
+    if (!opts.wechatDataPath || typeof opts.wechatDataPath !== "string") {
+      throw new Error("MD5KeyProvider: opts.wechatDataPath required");
+    }
+    this._wechatDataPath = opts.wechatDataPath;
+    this._uinOverride = opts.uin || null;
+    this._imeiOverride = opts.imei || null;
+    this._extractor = typeof opts.extractor === "function"
+      ? opts.extractor
+      : extractWeChatKey;
+    this._lastResult = null;
+  }
+
+  get name() {
+    return "md5";
+  }
+
+  /**
+   * @returns {Promise<string>}  7-char lowercase hex MD5 prefix
+   */
+  async getKey() {
+    const result = this._extractor({
+      wechatDataPath: this._wechatDataPath,
+      uin: this._uinOverride,
+      imei: this._imeiOverride,
+    });
+    this._lastResult = result;
+    if (!result || !result.key) {
+      const warnings = (result && result.warnings) || [];
+      const reason = warnings.length > 0 ? warnings.join("; ") : "key extraction returned empty";
+      throw new Error(`MD5KeyProvider.getKey: ${reason}`);
+    }
+    return result.key;
+  }
+
+  /**
+   * Last extraction result for telemetry / debugging — exposes uin /
+   * imei sources and warnings. Returns null until getKey() called.
+   */
+  getLastResult() {
+    return this._lastResult;
+  }
+}
+
+module.exports = { MD5KeyProvider };

package/lib/adapters/wechat/normalize.js

@@ -203,11 +203,20 @@ function contactDisplayName(byUsername, wxid) {
 function guessContactSubtype(row) {
   // rcontact.type bits: official accounts / group / regular contact /
   // black list. Detailed mapping in WeChat reverse-eng community —
-  // for v0.5 we keep it simple: anything that's not the user's self is
-  // "contact". Phase 12.6 will refine with full bit mapping.
-  if (typeof row.username === "string" && row.username.endsWith("@chatroom")) {
+  // for v0.5 we keep it simple: chatroom → unknown (not a Person),
+  // `gh_*` username → merchant (公众号 / Official Account — brand /
+  // business pushing content; closest enum match), rest → contact.
+  // Phase 12.6 will refine with full bit mapping + rcontact.type bits.
+  // (sjqz parity wechat.py:282 — get_friends() excludes gh_* from
+  // friends view but keeps them in contacts; we keep as Person with
+  // distinct subtype so Ask flow / EntityResolver can filter cleanly.)
+  if (typeof row.username !== "string") return "contact";
+  if (row.username.endsWith("@chatroom")) {
     return "unknown"; // chat group, not a Person
   }
+  if (row.username.startsWith("gh_")) {
+    return "merchant"; // 公众号 / Official Account
+  }
   return "contact";
 }
 

package/lib/analysis-skills/spending.js

@@ -69,7 +69,10 @@ class SpendingSkill extends AnalysisSkill {
 
   _fetchPaymentEvents({ since, until }) {
     const events = [];
-    const subtypes = ["payment", "transfer", "refund", "utility", "redenvelope", "investment", "income"];
+    // Phase 7 shopping adapters emit subtype="order" — must include so
+    // spending aggregates cover Taobao/JD/Meituan along with Alipay
+    // (payment/transfer) + Email (refund) etc.
+    const subtypes = ["payment", "transfer", "refund", "utility", "redenvelope", "investment", "income", "order"];
     for (const subtype of subtypes) {
       const q = { subtype, limit: 5000 };
       if (since != null) q.since = since;

package/lib/analysis.js

@@ -136,14 +136,26 @@ class AnalysisEngine {
       intent: parsed.intent,
       timeWindow: parsed.timeWindow,
       maxFacts: this.maxFacts,
+      vaultTotals: this._gatherVaultTotals(),
     });
 
-    // Call LLM.
+    // Call LLM. **skipCache: true** is critical: PDH answers depend on
+    // current vault state (new contacts / events / items ingested between
+    // asks). The desktop LLMManager has a 7-day ResponseCache keyed on
+    // sha256(messages); if a stale entry from before the latest sync hits,
+    // the user sees yesterday's hallucinated count after fixing _gatherFacts
+    // and never finds out (real-device verify 2026-05-21 Xiaomi 24115RA8EC:
+    // "几个联系人" served from cache, returned the pre-Path-C-fix wrong
+    // answer of "32" even though vault now had real contact data). PDH's
+    // freshness-over-latency tradeoff makes the cache strictly counter-
+    // productive at this layer. The cache for OTHER LLM uses (chat /
+    // skill orchestration / autonomous-agent) is unaffected.
     let llmResp;
     try {
       llmResp = await this.llm.chat(messages, {
         temperature: 0.2,
         purpose: "personal-data-hub.analysis.ask",
+        skipCache: true,
       });
     } catch (err) {
       const e = toError(err, "llm.chat");
@@ -195,6 +207,109 @@ class AnalysisEngine {
     };
   }
 
+  /**
+   * Retrieve the prompt context for a question WITHOUT calling the LLM.
+   *
+   * Mirrors the front half of `ask()` (parseQuery → gatherFacts → ragRetriever
+   * → buildPrompt) and returns the assembled messages + facts. The caller is
+   * responsible for invoking its own LLM with the returned messages and then
+   * (optionally) running citation validation on the answer.
+   *
+   * Why: lets a mobile / browser front-end host the LLM call locally (e.g.
+   * Android-side Volcengine Doubao adapter via API key) while keeping the
+   * vault + retrieval on the desktop. The privacy gate does NOT apply here
+   * because no LLM is contacted — the caller's gate is the gate.
+   *
+   * @param {string} question
+   * @param {object} [options]
+   * @param {number} [options.now]
+   * @param {boolean} [options.skipAudit=false]
+   * @returns {Promise<RetrieveContextResult>}
+   *
+   * @typedef {object} RetrieveContextResult
+   * @property {string} question
+   * @property {object} parsed
+   * @property {Array<object>} facts
+   * @property {string[]} factIds
+   * @property {number} factCount
+   * @property {boolean} truncated
+   * @property {string[]} ragContextIds
+   * @property {Array<{role: string, content: string}>} messages   prompt-builder output, LLM-ready
+   * @property {string} systemPrompt
+   * @property {number} retrievedAt                                Date.now() at start
+   * @property {number} durationMs
+   */
+  async retrieveContext(question, options = {}) {
+    if (typeof question !== "string" || question.length === 0) {
+      throw new Error("AnalysisEngine.retrieveContext: question must be a non-empty string");
+    }
+
+    const startedAt = Date.now();
+    const parsed = parseQuery(question, { now: options.now });
+    const facts = this._gatherFacts(parsed);
+
+    const ragContextIds = [];
+    if (this.ragRetriever) {
+      try {
+        const docs = await this.ragRetriever(question, parsed);
+        if (Array.isArray(docs)) {
+          for (const doc of docs) {
+            if (!doc || !doc.id) continue;
+            const e = this.vault.getEvent(doc.id);
+            if (e && !facts.find((f) => f.id === e.id)) {
+              facts.push(e);
+              ragContextIds.push(doc.id);
+            }
+          }
+        }
+      } catch (err) {
+        const e = toError(err, "ragRetriever");
+        try {
+          this.vault.audit("analysis.rag_failed", question, { error: e.message });
+        } catch (_e) { /* audit failures are non-fatal */ }
+      }
+    }
+
+    const { messages, factIds, factCount, truncated } = buildPrompt({
+      question,
+      facts,
+      systemPrompt: this.systemPrompt,
+      intent: parsed.intent,
+      timeWindow: parsed.timeWindow,
+      maxFacts: this.maxFacts,
+      vaultTotals: this._gatherVaultTotals(),
+    });
+
+    const durationMs = Date.now() - startedAt;
+
+    if (!options.skipAudit) {
+      try {
+        this.vault.audit("analysis.retrieve_context", question, {
+          factCount,
+          truncated,
+          ragContextIds: ragContextIds.length,
+          durationMs,
+        });
+      } catch (_e) { /* audit failures are non-fatal */ }
+    }
+
+    return {
+      question,
+      parsed,
+      facts,
+      // buildPrompt returns factIds as a Set; flatten to Array so the result
+      // round-trips through IPC / WS JSON serialization without becoming `{}`.
+      factIds: Array.from(factIds),
+      factCount,
+      truncated,
+      ragContextIds,
+      messages,
+      systemPrompt: this.systemPrompt,
+      retrievedAt: startedAt,
+      durationMs,
+    };
+  }
+
   // ─── Internals ─────────────────────────────────────────────────────
 
   _gatherFacts(parsed) {
@@ -215,7 +330,81 @@ class AnalysisEngine {
       if (Number.isFinite(parsed.timeWindow.since)) q.since = parsed.timeWindow.since;
       if (Number.isFinite(parsed.timeWindow.until)) q.until = parsed.timeWindow.until;
     }
-    return this.vault.queryEvents(q);
+    const events = this.vault.queryEvents(q);
+
+    // Path C follow-up — events alone miss whole categories of facts:
+    //  - contacts (system-data-android) land in `persons`, not `events`
+    //  - installed apps land in `items`, not `events`
+    //  - places (visited locations) live in `places`
+    // Without these the LLM gets 0 facts for "我有几个联系人" style questions
+    // and hallucinates a count. We pull a bounded slice of each entity type
+    // and append; prompt-builder.summarizeFact already handles `person` /
+    // `place` / fallback `item` shapes, so this is additive with no schema
+    // change to the LLM-facing prompt.
+    //
+    // Sizing: keep events as the majority (existing behavior is unchanged for
+    // event-heavy queries like 消费 / 通话); split the remaining 1/2 budget
+    // between persons + items. Time window + adapter filters don't apply to
+    // these tables (persons aren't time-stamped events) — they're current-
+    // state snapshots that should always be visible. Adapter filter is also
+    // skipped because users asking "我有几个联系人" don't say "from
+    // system-data-android".
+    const remaining = Math.max(0, this.maxFacts - events.length);
+    const sideBudget = Math.floor(remaining / 2);
+    const personBudget = sideBudget > 0 ? sideBudget : 0;
+    const itemBudget = remaining - personBudget;
+
+    let persons = [];
+    if (personBudget > 0) {
+      try {
+        persons = this.vault.queryPersons({ limit: personBudget });
+      } catch (_e) {
+        // Older vaults / forks without queryPersons — fall back gracefully.
+      }
+    }
+    let items = [];
+    if (itemBudget > 0) {
+      try {
+        items = this.vault.queryItems({ limit: itemBudget });
+      } catch (_e) {
+        /* same fallback */
+      }
+    }
+
+    return [...events, ...persons, ...items];
+  }
+
+  /**
+   * Pull authoritative entity counts from the vault. These go into the
+   * prompt's TOTALS block so the LLM can answer "how many X" questions
+   * correctly even when the FACTS sample is truncated (maxFacts cap).
+   *
+   * 2026-05-21 bug: LLM said "32 contacts" when vault actually had ~500.
+   * Root cause was a mix of (a) FACTS not including persons (fixed in
+   * _gatherFacts), and (b) LLM still counting FACTS array length even after
+   * persons were included — capped at the 80-fact ceiling. TOTALS bypasses
+   * both: it gives the LLM the real number to quote directly.
+   *
+   * Wrapped in try because legacy vault forks / mock vaults in tests may
+   * not expose `stats()`; falling back to undefined makes prompt-builder
+   * skip the block entirely.
+   */
+  _gatherVaultTotals() {
+    if (typeof this.vault.stats !== "function") return undefined;
+    try {
+      const s = this.vault.stats();
+      // Trim to the fields useful for question answering — schemaVersion /
+      // mergeGroups / audit log size are noise here.
+      return {
+        events: s.events,
+        persons: s.persons,
+        places: s.places,
+        items: s.items,
+        topics: s.topics,
+      };
+    } catch (_e) {
+      return undefined;
+    }
   }
 }