@chainlesschain/personal-data-hub 0.4.26 → 0.4.28

package/__tests__/adapters/wechat-pc-group-topic.test.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { describe, it, expect } from "vitest";
+
+const { WeChatPcAdapter } = require("../../lib/adapters/wechat-pc");
+
+// Build the raw envelope shape that WeChatPcAdapter.normalize() consumes for a
+// group message (the sync() generator yields { kind:"message", payload, ... }).
+function groupMessageRaw(payload) {
+  return {
+    adapter: "wechat-pc",
+    kind: "message",
+    originalId: "orig-1",
+    capturedAt: 1780000000000,
+    payload: { kind: "message", ...payload },
+  };
+}
+
+describe("wechat-pc — group topic naming", () => {
+  it("uses the resolved group display name for the topic when groupName is present", () => {
+    const adapter = new WeChatPcAdapter();
+    const out = adapter.normalize(groupMessageRaw({
+      talker: "45498354778@chatroom",
+      isGroup: true,
+      senderWxid: "wxid_friend",
+      groupName: "家庭群",
+      text: "晚饭吃什么",
+      createdTimeMs: 1780000000000,
+    }));
+    expect(out.topics).toHaveLength(1);
+    // Stable id keyed on the chatroom wxid (identity unchanged)...
+    expect(out.topics[0].id).toBe("topic-wechat-group-45498354778@chatroom");
+    // ...but the human-readable display name is used, NOT the numeric id.
+    expect(out.topics[0].name).toBe("家庭群");
+  });
+
+  it("falls back to the raw numeric id when no group name was resolved", () => {
+    const adapter = new WeChatPcAdapter();
+    const out = adapter.normalize(groupMessageRaw({
+      talker: "45498354778@chatroom",
+      isGroup: true,
+      senderWxid: "wxid_friend",
+      groupName: null,
+      text: "hi",
+      createdTimeMs: 1780000000000,
+    }));
+    expect(out.topics).toHaveLength(1);
+    expect(out.topics[0].name).toBe("45498354778");
+  });
+
+  it("blank/whitespace group name falls back to the raw id (no empty topic name)", () => {
+    const adapter = new WeChatPcAdapter();
+    const out = adapter.normalize(groupMessageRaw({
+      talker: "12345@chatroom",
+      isGroup: true,
+      senderWxid: "wxid_x",
+      groupName: "   ",
+      text: "hi",
+      createdTimeMs: 1780000000000,
+    }));
+    expect(out.topics[0].name).toBe("12345");
+  });
+});

package/__tests__/analysis-skills.test.js

@@ -498,6 +498,32 @@ describe("InterestsSkill", () => {
     expect(r.topTopics[0].name).toBe("Travel");
     expect(r.llmInterests).toBeNull();
   });
+
+  it("drops unresolved numeric group-id topics (e.g. WeChat chatroom ids) from the profile", async () => {
+    // Real interest topic
+    rig.vault.putTopic({
+      id: "topic-doubao", type: "topic", name: "豆包",
+      derivedFromEvents: ["e1"],
+      ingestedAt: Date.now(), source: defaultSource("test"),
+    });
+    // Unresolved group-chat topics named by raw numeric chatroom id — noise.
+    rig.vault.putTopic({
+      id: "topic-g1", type: "topic", name: "45498354778",
+      derivedFromEvents: [],
+      ingestedAt: Date.now() + 1, source: defaultSource("test"),
+    });
+    rig.vault.putTopic({
+      id: "topic-g2", type: "topic", name: "54346634535",
+      derivedFromEvents: [],
+      ingestedAt: Date.now() + 2, source: defaultSource("test"),
+    });
+    const skill = new InterestsSkill({ vault: rig.vault });
+    const r = await skill.run({});
+    const names = r.topTopics.map((t) => t.name);
+    expect(names).toContain("豆包");
+    expect(names).not.toContain("45498354778");
+    expect(names).not.toContain("54346634535");
+  });
 });
 
 // ─── TimelineSkill ──────────────────────────────────────────────────────
@@ -534,6 +560,34 @@ describe("TimelineSkill", () => {
     const r = await skill.run({ since: ts(2026, 4, 1) });
     expect(r.llm_narrative).toBe("你这周点了一次外卖。");
   });
+
+  it("excludes inventory-snapshot events (installed-app / contact roster) from the narrative", async () => {
+    // Real activity event (extra has no `kind` → must be kept)
+    makePayment(rig.vault, { id: "act-1", occurredAt: ts(2026, 5, 1), counterpartyName: "美团", amount: 10, adapter: "alipay-bill", title: "外卖" });
+    // Inventory-snapshot events stamped at a LATER (collection) time — these
+    // would dominate a DESC time query but must be filtered out.
+    rig.vault.putEvent({
+      id: "event-android-app-com.x", type: "event", subtype: "other",
+      occurredAt: ts(2026, 6, 1), actor: "person-self",
+      content: { title: "应用：X" },
+      ingestedAt: Date.now(), source: defaultSource("system-data-android"),
+      extra: { kind: "app-snapshot", packageName: "com.x" },
+    });
+    rig.vault.putEvent({
+      id: "event-android-contact-y", type: "event", subtype: "other",
+      occurredAt: ts(2026, 6, 1), actor: "person-self",
+      content: { title: "联系人：Y" },
+      ingestedAt: Date.now(), source: defaultSource("system-data-android"),
+      extra: { kind: "contact-snapshot" },
+    });
+    const skill = new TimelineSkill({ vault: rig.vault });
+    const r = await skill.run({ since: ts(2026, 4, 1) });
+    const ids = r.entries.map((e) => e.id);
+    expect(ids).toContain("act-1");
+    expect(ids).not.toContain("event-android-app-com.x");
+    expect(ids).not.toContain("event-android-contact-y");
+    expect(r.summary.totalEvents).toBe(1);
+  });
 });
 
 // ─── runAnalysisSkill dispatcher ─────────────────────────────────────────

package/__tests__/salvage-ingest.test.js

@@ -0,0 +1,97 @@
+"use strict";
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const { LocalVault } = require("../lib/vault");
+const { generateKeyHex } = require("../lib/key-providers");
+const {
+  buildSalvageEvents,
+  salvageDumpToVault,
+  resolveApp,
+} = require("../lib/forensics/salvage-ingest");
+
+// Build a real SQLite DB and treat its bytes as a memory dump; verify the
+// generic salvage→vault path recovers messages AND tags them with the correct
+// per-app source.adapter (multi-app de-silo). Real LocalVault → proves the
+// hand-built events pass schema validation + are searchable.
+describe("salvage-ingest — generic multi-app salvage → vault", () => {
+  let dir, dumpPath, vault, vdir;
+  const COLUMNS = ["msg_uuid", "conversation_id", "sender", "content", "created_time"];
+
+  beforeAll(() => {
+    const Database = require("better-sqlite3-multiple-ciphers");
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "salvage-ing-"));
+    dumpPath = path.join(dir, "u.db");
+    const db = new Database(dumpPath);
+    db.exec("CREATE TABLE msg(msg_uuid TEXT, conversation_id TEXT, sender INTEGER, content TEXT, created_time INTEGER)");
+    const ins = db.prepare("INSERT INTO msg VALUES(?,?,?,?,?)");
+    ins.run("u1", "conv-1", 111, "今天的会议改到下午三点 hi", 1700000000000);
+    ins.run("u2", "conv-1", 222, "收到 👌", 1700000001000);
+    db.close();
+
+    vdir = fs.mkdtempSync(path.join(os.tmpdir(), "salvage-vault-"));
+    vault = new LocalVault({ path: path.join(vdir, "v.db"), key: generateKeyHex() });
+    vault.open();
+  });
+
+  afterAll(() => {
+    try { vault.close(); } catch (_e) {}
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
+    try { fs.rmSync(vdir, { recursive: true, force: true }); } catch (_e) {}
+  });
+
+  it("resolveApp maps known apps to canonical source adapters; unknown → salvage:<app>", () => {
+    expect(resolveApp("douyin").sourceAdapter).toBe("social-douyin");
+    expect(resolveApp("toutiao").sourceAdapter).toBe("social-toutiao");
+    expect(resolveApp("wechat").sourceAdapter).toBe("wechat");
+    expect(resolveApp("kuaishou").sourceAdapter).toBe("social-kuaishou");
+    expect(resolveApp("bogusapp").sourceAdapter).toBe("salvage:bogusapp");
+  });
+
+  it("buildSalvageEvents tags per-app source + builds valid message events", () => {
+    const recs = [{ rowid: "1", cols: ["u1", "conv-1", 111, "hello 世界", 1700000000000] }];
+    const built = buildSalvageEvents(recs, { app: "toutiao", columns: COLUMNS, now: 1700000099000 });
+    expect(built.events.length).toBe(1);
+    const e = built.events[0];
+    expect(e.source.adapter).toBe("social-toutiao");
+    expect(e.source.capturedBy).toBe("sqlite"); // schema enum; provenance in extra.salvaged
+    expect(e.subtype).toBe("message");
+    expect(e.content.text).toBe("hello 世界");
+    expect(e.extra.platform).toBe("toutiao");
+    expect(e.extra.salvaged).toBe(true);
+  });
+
+  it("salvageDumpToVault ingests with douyin source + events are searchable", () => {
+    const r = salvageDumpToVault(vault, dumpPath, { app: "douyin", columns: COLUMNS, now: 1700000099000 });
+    expect(r.app).toBe("douyin");
+    expect(r.sourceAdapter).toBe("social-douyin");
+    expect(r.ingested).toBe(2);
+    // events landed under the correct source + are searchable
+    const events = vault.queryEvents({ limit: 100 }) || [];
+    const douyin = events.filter((e) => e.source && e.source.adapter === "social-douyin");
+    expect(douyin.length).toBe(2);
+    const texts = douyin.map((e) => e.content && e.content.text).sort();
+    expect(texts).toContain("收到 👌"); // UTF-8 emoji survives
+  });
+
+  it("same dump under a different app tags a different source (no cross-attribution)", () => {
+    const r = salvageDumpToVault(vault, dumpPath, { app: "toutiao", columns: COLUMNS, now: 1700000099000 });
+    expect(r.sourceAdapter).toBe("social-toutiao");
+    expect(r.ingested).toBe(2);
+    const events = vault.queryEvents({ limit: 100 }) || [];
+    expect(events.filter((e) => e.source && e.source.adapter === "social-toutiao").length).toBe(2);
+    // douyin events from prior test remain distinct
+    expect(events.filter((e) => e.source && e.source.adapter === "social-douyin").length).toBe(2);
+  });
+
+  it("re-ingesting the same dump dedups (stable originalId)", () => {
+    const before = (vault.queryEvents({ limit: 200 }) || []).length;
+    salvageDumpToVault(vault, dumpPath, { app: "douyin", columns: COLUMNS, now: 1700000099000 });
+    const after = (vault.queryEvents({ limit: 200 }) || []).length;
+    expect(after).toBe(before); // ON CONFLICT(source_adapter, source_original_id) updates, no dupes
+  });
+});

package/lib/adapters/wechat-pc/index.js

@@ -290,6 +290,22 @@ class WeChatPcAdapter {
       null;
     const fallbackCapturedAt = Date.now();
     const messages = (result && Array.isArray(result.messages)) ? result.messages : [];
+    // Harvest group display names from the contact roster: WeChat stores group
+    // chatrooms (wxid ending @chatroom) in contact.db with a nickname/remark.
+    // They are skipped as Person entities below, but their names let us label
+    // group Topics with a human-readable name instead of the raw numeric id.
+    const groupNames = new Map();
+    {
+      const contactsForNames = (result && Array.isArray(result.contacts)) ? result.contacts : [];
+      for (const c of contactsForNames) {
+        if (!c || typeof c.wxid !== "string" || !c.wxid.endsWith("@chatroom")) continue;
+        const nm =
+          (typeof c.remark === "string" && c.remark.trim()) ||
+          (typeof c.nickname === "string" && c.nickname.trim()) ||
+          "";
+        if (nm) groupNames.set(c.wxid, nm);
+      }
+    }
     let emitted = 0;
     // The sidecar already applied `limit` across all sources (chat/biz/sns/
     // favorite). Yield everything it returned — do NOT re-cap here, or the
@@ -311,6 +327,7 @@ class WeChatPcAdapter {
         text: typeof m.text === "string" ? m.text : "",
         senderWxid: isGroup ? (m.sender || null) : null,
         isGroup,
+        groupName: isGroup && conv ? (groupNames.get(conv) || null) : null,
         contentBlob: typeof m.text === "string" ? m.text : null,
         // provenance: chat | biz(公众号) | sns(朋友圈) | favorite(收藏)
         wechatSource: typeof m.source === "string" ? m.source : "chat",
@@ -423,10 +440,16 @@ function normalizeMessage(p, raw, ingestedAt) {
 
   const topics = [];
   if (isGroup && p.talker) {
+    // Prefer the resolved group display name (harvested from contact.db in
+    // sync()); fall back to the raw numeric chatroom id only when unknown.
+    const groupName =
+      (typeof p.groupName === "string" && p.groupName.trim())
+        ? p.groupName.trim()
+        : p.talker.replace("@chatroom", "");
     topics.push({
       id: `topic-wechat-group-${p.talker}`,
       type: ENTITY_TYPES.TOPIC,
-      name: p.talker.replace("@chatroom", ""),
+      name: groupName,
       ingestedAt,
       source,
       extra: { platform: "wechat", source: "pc", wxid: p.talker },

package/lib/analysis-skills/interests.js

@@ -28,6 +28,21 @@
 
 const { AnalysisSkill } = require("./base");
 
+/**
+ * A topic name carries real interest signal only if it is a human-readable
+ * label. Unresolved group-chat IDs (e.g. WeChat group topics named by their
+ * raw numeric chatroom id "45498354778") and empty names are NOT interests —
+ * they would crowd out genuine topics (coffee, photography, 豆包...) in the
+ * profile. Drop them.
+ */
+function isMeaningfulTopicName(name) {
+  if (typeof name !== "string") return false;
+  const s = name.trim();
+  if (s.length === 0) return false;
+  if (/^\d+$/.test(s)) return false; // pure-numeric = unresolved group id
+  return true;
+}
+
 class InterestsSkill extends AnalysisSkill {
   constructor(opts) {
     super({ ...opts, name: "analysis.interests" });
@@ -61,25 +76,30 @@ class InterestsSkill extends AnalysisSkill {
     let topics = [];
     try {
       const db = this.vault._requireOpen();
+      // Over-fetch (×20, capped) before filtering: vaults can hold thousands
+      // of unresolved numeric group-chat topics that would otherwise starve
+      // the few human-readable interest topics out of the top-N budget.
       topics = db.prepare(
         "SELECT id, name, derived_from_events, ingested_at FROM topics ORDER BY ingested_at DESC LIMIT ?"
-      ).all(topN * 3);
+      ).all(Math.min(topN * 20, 2000));
     } catch (_e) {
       // Older vaults may not have topics; non-fatal.
     }
-    const mapped = topics.map((t) => {
-      let eventCount = 0;
-      try {
-        const arr = t.derived_from_events ? JSON.parse(t.derived_from_events) : [];
-        if (Array.isArray(arr)) eventCount = arr.length;
-      } catch (_e) {}
-      return {
-        id: t.id,
-        name: t.name,
-        eventCount,
-        lastSeen: t.ingested_at || null,
-      };
-    });
+    const mapped = topics
+      .filter((t) => isMeaningfulTopicName(t.name))
+      .map((t) => {
+        let eventCount = 0;
+        try {
+          const arr = t.derived_from_events ? JSON.parse(t.derived_from_events) : [];
+          if (Array.isArray(arr)) eventCount = arr.length;
+        } catch (_e) {}
+        return {
+          id: t.id,
+          name: t.name,
+          eventCount,
+          lastSeen: t.ingested_at || null,
+        };
+      });
     return mapped
       .sort((a, b) => (b.eventCount - a.eventCount) || ((b.lastSeen || 0) - (a.lastSeen || 0)))
       .slice(0, topN);

package/lib/analysis-skills/timeline.js

@@ -63,7 +63,12 @@ class TimelineSkill extends AnalysisSkill {
   }
 
   _fetchEvents({ since, until }, limit) {
-    const q = { limit };
+    // Exclude inventory-snapshot events (installed-app roster + contact
+    // roster from system-data-android). They carry a synthetic
+    // collection-time occurredAt — tens of thousands of them cluster at one
+    // recent timestamp and would otherwise crowd out real activity from this
+    // chronological narrative. They remain in the vault for facet counts.
+    const q = { limit, excludeExtraKinds: ["app-snapshot", "contact-snapshot"] };
     if (since != null) q.since = since;
     if (until != null) q.until = until;
     const events = this.vault.queryEvents(q) || [];

package/lib/forensics/salvage-ingest.js

@@ -0,0 +1,160 @@
+"use strict";
+/*
+ * Generic salvage → vault ingest (multi-app, correct source attribution).
+ *
+ * The leaf-page salvager recovers raw {rowid, cols} tuples from a /proc/mem
+ * dump of ANY app. This maps them into MESSAGE events and writes them straight
+ * to the vault with the CORRECT per-app `source.adapter` — so 抖音 data shows as
+ * social-douyin, 头条 as social-toutiao, 微信 as wechat, etc., instead of all
+ * being mis-attributed to one adapter.
+ *
+ * Why direct vault.putBatch (not registry.syncAdapter): the registry path runs
+ * an adapter's normalize(), which hard-stamps that adapter's name as the source.
+ * For salvaged cross-app data we need to stamp the source per the app the dump
+ * came from. Building events here + putBatch keeps attribution correct and is
+ * engine-agnostic. Events are tagged `extra.capturedBy = "mem-salvage"` for
+ * provenance + `extra.salvaged = true`.
+ *
+ * Authorization: only on data you are entitled to (your own device/account).
+ * Docs: docs/internal/pdh-db-decryption-runbook.md (Method B).
+ */
+const { newId } = require("../ids");
+const { salvageFile } = require("./leaf-salvage");
+const {
+  mapMsgRecords,
+  inferMsgColumns,
+} = require("../adapters/social-douyin-adb/salvage-mapper");
+
+const SALVAGE_VERSION = "salvage-0.1";
+
+// appKey → { sourceAdapter (vault source.adapter, = the app's canonical adapter
+// name so byApp aggregation attributes correctly), platform }. Unknown apps
+// fall back to a "salvage:<app>" source so they're still distinct + traceable.
+const APP_SALVAGE = Object.freeze({
+  douyin: { sourceAdapter: "social-douyin", platform: "douyin" },
+  toutiao: { sourceAdapter: "social-toutiao", platform: "toutiao" },
+  kuaishou: { sourceAdapter: "social-kuaishou", platform: "kuaishou" },
+  xiaohongshu: { sourceAdapter: "social-xiaohongshu", platform: "xiaohongshu" },
+  weibo: { sourceAdapter: "social-weibo", platform: "weibo" },
+  wechat: { sourceAdapter: "wechat", platform: "wechat" },
+  qq: { sourceAdapter: "qq", platform: "qq" },
+});
+
+function resolveApp(app) {
+  const key = String(app || "douyin").toLowerCase();
+  return APP_SALVAGE[key] || { sourceAdapter: `salvage:${key}`, platform: key };
+}
+
+// Stable, content-derived hash → dedup key. Same message salvaged again
+// (re-scan) collides on ON CONFLICT(source_adapter, source_original_id) and
+// updates rather than duplicating. Tiny FNV-1a over the salient fields.
+function _stableKey(parts) {
+  const s = parts.join("|");
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+
+/**
+ * Map salvaged records → MESSAGE events tagged with the per-app source.
+ * @param {Array<{rowid,cols}>} records
+ * @param {{ app?: string, columns?: string[], now?: number }} [opts]
+ * @returns {{ events: object[], mapped: number, columns: string[], sourceAdapter: string }}
+ */
+function buildSalvageEvents(records, opts = {}) {
+  const cfg = resolveApp(opts.app);
+  const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+  const columns = Array.isArray(opts.columns) && opts.columns.length
+    ? opts.columns
+    : inferMsgColumns(records || []);
+  const messages = mapMsgRecords(records || [], columns);
+  const events = [];
+  for (const m of messages) {
+    const text = typeof m.text === "string" ? m.text : "";
+    const occurredAt = Number.isFinite(m.createdTimeMs) && m.createdTimeMs > 0
+      ? m.createdTimeMs
+      : now;
+    const key = _stableKey([
+      cfg.platform,
+      String(m.conversationId || m.senderUid || ""),
+      String(occurredAt),
+      text.slice(0, 64),
+    ]);
+    events.push({
+      id: newId(),
+      type: "event",
+      subtype: "message",
+      occurredAt,
+      actor: "person-self",
+      content: {
+        title: text ? text.slice(0, 80) : "(非文本消息)",
+        text,
+      },
+      ingestedAt: now,
+      source: {
+        adapter: cfg.sourceAdapter,
+        adapterVersion: SALVAGE_VERSION,
+        originalId: `salvage:${cfg.platform}:${key}`,
+        capturedAt: occurredAt,
+        // schema enum: export|api|sqlite|accessibility|ocr|manual. Salvaged
+        // pages ARE SQLite rows; mem-salvage provenance lives in extra.salvaged.
+        capturedBy: "sqlite",
+      },
+      extra: {
+        platform: cfg.platform,
+        channel: "im",
+        salvaged: true,
+        senderUid: m.senderUid || null,
+        conversationId: m.conversationId || null,
+        contentBlob: typeof m.contentBlob === "string" ? m.contentBlob : null,
+      },
+    });
+  }
+  return { events, mapped: messages.length, columns, sourceAdapter: cfg.sourceAdapter };
+}
+
+/**
+ * Salvage a memory dump and write the recovered messages straight into the
+ * vault with the correct per-app source. Returns counts.
+ *
+ * @param {object} vault  LocalVault (must expose putBatch)
+ * @param {string} dumpPath
+ * @param {{ app?: string, columns?: string[], unaligned?: boolean, pageSize?: number, minCols?: number, now?: number }} [opts]
+ * @returns {{ ingested: number, salvaged: number, app: string, sourceAdapter: string, leafPages: number }}
+ */
+function salvageDumpToVault(vault, dumpPath, opts = {}) {
+  if (!vault || typeof vault.putBatch !== "function") {
+    throw new TypeError("salvageDumpToVault: vault with putBatch required");
+  }
+  if (typeof dumpPath !== "string" || !dumpPath) {
+    throw new TypeError("salvageDumpToVault: dumpPath required");
+  }
+  const { records, pages } = salvageFile(dumpPath, {
+    pageSize: opts.pageSize,
+    minCols: opts.minCols,
+    unaligned: opts.unaligned,
+    stride: opts.stride,
+  });
+  const built = buildSalvageEvents(records, opts);
+  const res = built.events.length
+    ? vault.putBatch({ events: built.events })
+    : { events: 0 };
+  return {
+    ingested: res.events || 0,
+    salvaged: records.length,
+    mapped: built.mapped,
+    app: String(opts.app || "douyin").toLowerCase(),
+    sourceAdapter: built.sourceAdapter,
+    leafPages: pages,
+  };
+}
+
+module.exports = {
+  APP_SALVAGE,
+  resolveApp,
+  buildSalvageEvents,
+  salvageDumpToVault,
+};

package/lib/vault.js

@@ -811,6 +811,18 @@ class LocalVault {
       where.push("source_adapter = @adapter");
       params.adapter = q.adapter;
     }
+    if (Array.isArray(q.excludeExtraKinds) && q.excludeExtraKinds.length > 0) {
+      // Exclude inventory-snapshot events (e.g. installed-app / contact-roster
+      // facet events) whose extra.kind is in the given list. Those carry a
+      // synthetic collection-time occurredAt and would otherwise dominate any
+      // time-ordered (occurred_at DESC) query. Rows with no extra.kind are kept.
+      const placeholders = q.excludeExtraKinds.map((_v, i) => `@xk${i}`);
+      q.excludeExtraKinds.forEach((v, i) => { params[`xk${i}`] = v; });
+      where.push(
+        "(json_extract(extra, '$.kind') IS NULL OR json_extract(extra, '$.kind') NOT IN (" +
+        placeholders.join(", ") + "))",
+      );
+    }
 
     const limit = Number.isInteger(q.limit) && q.limit > 0 ? Math.min(q.limit, 10000) : 100;
     const offset = Number.isInteger(q.offset) && q.offset >= 0 ? q.offset : 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlesschain/personal-data-hub",
-  "version": "0.4.26",
+  "version": "0.4.28",
   "description": "Personal Data Hub — UnifiedSchema + validators + KG ingest helpers for the data-back-to-the-individual middleware",
   "type": "commonjs",
   "main": "lib/index.js",
@@ -68,7 +68,9 @@
     "./adapters/messaging-qq": "./lib/adapters/messaging-qq/index.js",
     "./adapters/messaging-telegram": "./lib/adapters/messaging-telegram/index.js",
     "./adapters/messaging-whatsapp": "./lib/adapters/messaging-whatsapp/index.js",
-    "./sidecar": "./lib/sidecar/index.js"
+    "./sidecar": "./lib/sidecar/index.js",
+    "./forensics/leaf-salvage": "./lib/forensics/leaf-salvage.js",
+    "./forensics/salvage-ingest": "./lib/forensics/salvage-ingest.js"
   },
   "scripts": {
     "test": "vitest run",