@chainlesschain/personal-data-hub 0.2.1 → 0.2.3

package/__tests__/adapters/social-toutiao-kuaishou-scaffold.test.js

@@ -1,14 +1,18 @@
 /**
- * Phase 13.8+13.9 — Toutiao 今日头条 + Kuaishou 快手 v0.1 scaffold tests.
+ * §A8 v0.2 — Toutiao 今日头条 + Kuaishou 快手 sqlite-mode tests.
+ *
+ * Originally Phase 13.8+13.9 v0.1 scaffold tests; promoted in §A8 v0.2 to
+ * cover the dual-mode (snapshot + sqlite) adapter. Snapshot-mode coverage
+ * lives in `../social-{toutiao,kuaishou}-snapshot.test.js`; this file
+ * focuses on the legacy sqlite/device-pull path that desktop wiring still
+ * uses for PCs running AndroidExtractor.
  *
- * Tests are intentionally focused on scaffold-quality guarantees:
  *   - Adapter contract conformance (assertAdapter ok)
- *   - Account validation (rejects missing uid)
  *   - sync() yields raw rows per `kind` from mocked SQLite driver
  *   - normalize() produces valid UnifiedSchema events with correct subtype
- *
- * Field-level assertions intentionally avoided — schema is待 fixture pin
- * in Phase 13.10 (real-device E2E).
+ *   - Account validation lazy-checked at sync() time (v0.2 changed:
+ *     account.uid is now OPTIONAL at construction so snapshot-mode-only
+ *     callers can omit it).
  */
 
 "use strict";
@@ -50,18 +54,37 @@ function withFakeDb(fn) {
 
 // ─── ToutiaoAdapter ─────────────────────────────────────────────────────
 
-describe("ToutiaoAdapter — Phase 13.8(+) v0.1 scaffold", () => {
+describe("ToutiaoAdapter — §A8 v0.2 sqlite mode", () => {
   it("contract conformance + sensitivity high (news reading reveals political/medical interest)", () => {
     const a = new ToutiaoAdapter({ account: { uid: "u-1" } });
     expect(assertAdapter(a).ok).toBe(true);
     expect(a.name).toBe("social-toutiao");
     expect(a.extractMode).toBe("device-pull");
     expect(a.dataDisclosure.sensitivity).toBe("high");
+    // v0.2 dual-mode capabilities — adapter accepts both snapshot and sqlite.
+    expect(a.capabilities).toContain("sync:snapshot");
+    expect(a.capabilities).toContain("sync:sqlite");
+  });
+
+  it("v0.2: account OPTIONAL at construction (snapshot mode is stateless)", () => {
+    // Used to throw in v0.1 — now legal. Sqlite-mode sync() will lazy-throw.
+    expect(() => new ToutiaoAdapter()).not.toThrow();
+    expect(() => new ToutiaoAdapter({})).not.toThrow();
+    expect(() => new ToutiaoAdapter({ account: {} })).not.toThrow();
   });
 
-  it("rejects missing account.uid", () => {
-    expect(() => new ToutiaoAdapter({})).toThrow();
-    expect(() => new ToutiaoAdapter({ account: {} })).toThrow(/uid/);
+  it("sqlite mode lazy-throws when account.uid missing at sync time", async () => {
+    const a = new ToutiaoAdapter({ dbPath: "/no/such/path.db" });
+    let threw = null;
+    try {
+      for await (const _r of a.sync()) {
+        /* drain */
+      }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/account\.uid required/);
   });
 
   it("sync yields read + collection + search raws via mocked driver", async () => {
@@ -130,9 +153,11 @@ describe("ToutiaoAdapter — Phase 13.8(+) v0.1 scaffold", () => {
     }
   });
 
-  it("normalize throws on missing payload.row (validator-friendly)", () => {
+  it("normalize throws on missing payload row + no snapshot fields (validator-friendly)", () => {
     const a = new ToutiaoAdapter({ account: { uid: "u-1" } });
-    expect(() => a.normalize({ payload: {} })).toThrow(/row missing/);
+    // v0.2: row-missing check moved into per-kind normalizers (snapshot
+    // payloads have no `row` but carry fields directly).
+    expect(() => a.normalize({ payload: { kind: "read" } })).toThrow(/row missing/);
   });
 
   it("search keyword preserved verbatim in content.title + extra.keyword", () => {
@@ -158,18 +183,35 @@ describe("ToutiaoAdapter — Phase 13.8(+) v0.1 scaffold", () => {
 
 // ─── KuaishouAdapter ────────────────────────────────────────────────────
 
-describe("KuaishouAdapter — Phase 13.9(+) v0.1 scaffold", () => {
+describe("KuaishouAdapter — §A8 v0.2 sqlite mode", () => {
   it("contract conformance + sensitivity medium (entertainment preference)", () => {
     const a = new KuaishouAdapter({ account: { uid: "u-2" } });
     expect(assertAdapter(a).ok).toBe(true);
     expect(a.name).toBe("social-kuaishou");
     expect(a.extractMode).toBe("device-pull");
     expect(a.dataDisclosure.sensitivity).toBe("medium");
+    expect(a.capabilities).toContain("sync:snapshot");
+    expect(a.capabilities).toContain("sync:sqlite");
+  });
+
+  it("v0.2: account OPTIONAL at construction (snapshot mode is stateless)", () => {
+    expect(() => new KuaishouAdapter()).not.toThrow();
+    expect(() => new KuaishouAdapter({})).not.toThrow();
+    expect(() => new KuaishouAdapter({ account: {} })).not.toThrow();
   });
 
-  it("rejects missing account.uid", () => {
-    expect(() => new KuaishouAdapter({})).toThrow();
-    expect(() => new KuaishouAdapter({ account: {} })).toThrow(/uid/);
+  it("sqlite mode lazy-throws when account.uid missing at sync time", async () => {
+    const a = new KuaishouAdapter({ dbPath: "/no/such/path.db" });
+    let threw = null;
+    try {
+      for await (const _r of a.sync()) {
+        /* drain */
+      }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/account\.uid required/);
   });
 
   it("sync yields watch + collect + search raws via mocked driver", async () => {

package/__tests__/adapters/wechat-frida-agent.test.js

@@ -171,6 +171,134 @@ describe("frida-agent — fallback symbol resolution", () => {
   });
 });
 
+describe("frida-agent — sjqz-audit fixes (sig + format + module case)", () => {
+  // Helper extending fakePtr with readCString for ascii-hex tests.
+  function fakeAsciiHexPtr(asciiHex) {
+    return {
+      _v: asciiHex,
+      toInt32() { return 0; },
+      readByteArray(_len) { return new Uint8Array(0).buffer; },
+    };
+  }
+  function memoryReadCString(ptr, _maxLen) {
+    return ptr && typeof ptr._v === "string" ? ptr._v : null;
+  }
+
+  it("attaches when only uppercase libWCDB.so resolves (sjqz canonical name)", () => {
+    const send = vi.fn();
+    const Interceptor = { attach: vi.fn() };
+    const Module = {
+      findExportByName(mod, sym) {
+        return mod === "libWCDB.so" && sym === "sqlite3_key"
+          ? { symbol: sym }
+          : null;
+      },
+    };
+    const Process = {
+      findModuleByName(mod) {
+        return mod === "libWCDB.so" ? { name: mod } : null;
+      },
+    };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    const hooked = send.mock.calls.find((c) => c[0].kind === "hooked");
+    expect(hooked).toBeDefined();
+    expect(hooked[0].module).toBe("libWCDB.so");
+  });
+
+  it("v2 hook reads key from args[2] and length from args[3] (not args[1]/[2])", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === "sqlite3_key_v2" ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    // sqlite3_key_v2(sqlite3 *db, const char *zDbName, const void *pKey, int nKey)
+    // args[0]=db, args[1]=name, args[2]=keyBytes, args[3]=len
+    const dbNamePtr = fakePtr("ffeeffeeffeeffeeffeeffeeffeeffee");  // would be wrong if read as key
+    const keyHex = "12345678" + "00".repeat(28);                     // 32 bytes
+    const args = [
+      fakePtr(0),                   // db
+      dbNamePtr,                    // name (NOT the key)
+      fakePtr(keyHex),              // pKey — correct args[2]
+      fakePtr(32),                  // nKey — correct args[3]
+    ];
+    attached.sqlite3_key_v2.onEnter(args);
+
+    const keyEvt = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(keyEvt).toBeDefined();
+    expect(keyEvt[0].hex).toBe(keyHex);           // proves args[2] was read, not args[1]
+    expect(keyEvt[0].sig).toBe("v2");
+    expect(keyEvt[0].format).toBe("raw-bytes");
+    expect(keyEvt[0].length).toBe(32);
+  });
+
+  it("reads ascii-hex key via readCString when length === 64", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === "sqlite3_key" ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+    const Memory = { readCString: memoryReadCString };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send, Memory });
+
+    // 64-char ASCII hex string + len=64 → readCString path (sjqz scenario)
+    const asciiHex = "ABCDEF0123456789".repeat(4).toLowerCase();
+    const args = [fakePtr(0), fakeAsciiHexPtr(asciiHex), fakePtr(64)];
+    attached.sqlite3_key.onEnter(args);
+
+    const keyEvt = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(keyEvt).toBeDefined();
+    expect(keyEvt[0].hex).toBe(asciiHex);
+    expect(keyEvt[0].format).toBe("ascii-hex");
+    expect(keyEvt[0].length).toBe(64);
+  });
+
+  it("emits unsupported-signature error for mangled C++ symbol (no host attempt)", () => {
+    const send = vi.fn();
+    const attached = {};
+    const Interceptor = {
+      attach(addr, handlers) { attached[addr.symbol] = handlers; },
+    };
+    const mangledSymbol =
+      "_ZN4WCDB8Database13setCipherKeyERKNSt6__ndk112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE";
+    const Module = {
+      findExportByName(mod, sym) {
+        return sym === mangledSymbol ? { symbol: sym } : null;
+      },
+    };
+    const Process = { findModuleByName() { return { name: "libwcdb.so" }; } };
+
+    runAgentUnderMock({ Module, Process, Interceptor, send });
+
+    attached[mangledSymbol].onEnter([fakePtr(0), fakePtr("aabb"), fakePtr(32)]);
+
+    const errEvt = send.mock.calls.find(
+      (c) => c[0].kind === "error" && /unsupported symbol signature/.test(c[0].message),
+    );
+    expect(errEvt).toBeDefined();
+    // And NO key event emitted (host must fall back to MD5 path).
+    const keyEvt = send.mock.calls.find((c) => c[0].kind === "key");
+    expect(keyEvt).toBeUndefined();
+  });
+});
+
 describe("frida-agent — module not yet loaded path", () => {
   it("emits module-waiting and schedules retry", () => {
     const send = vi.fn();
@@ -183,7 +311,10 @@ describe("frida-agent — module not yet loaded path", () => {
 
     const waiting = send.mock.calls.find((c) => c[0].kind === "module-waiting");
     expect(waiting).toBeDefined();
-    expect(waiting[0].module).toBe("libwcdb.so");
+    // Post-sjqz audit: agent now tries both libWCDB.so (uppercase, sjqz-verified)
+    // and libwcdb.so. The module-waiting event surfaces the join so the
+    // host telemetry shows both attempted names.
+    expect(waiting[0].module).toBe("libWCDB.so|libwcdb.so");
     expect(setTimeoutMock).toHaveBeenCalled();
     // First retry delay 500ms
     expect(setTimeoutMock.mock.calls[0][1]).toBe(500);

package/__tests__/integration/social-bilibili-pipeline.test.js

@@ -0,0 +1,261 @@
+"use strict";
+
+/**
+ * Integration test — A8 v0.1 Bilibili snapshot → vault pipeline.
+ *
+ * Exercises the full chain WITHOUT any real WebView / OkHttp / Android JNI:
+ *
+ *   Synthetic snapshot JSON (4 kinds)
+ *      ↓
+ *   AdapterRegistry (real) + LocalVault (real, SQLCipher)
+ *      ↓
+ *   adapter.sync({ inputPath }) → _syncViaSnapshot yields raw events
+ *      ↓
+ *   registry.putRawEvent → vault.raw_events
+ *      ↓
+ *   adapter.normalize(raw) → batch
+ *      ↓
+ *   vault.putBatch → events / persons / places / items / topics tables
+ *
+ * Two scenarios:
+ *   A. happy path — 4-kind snapshot ingests; vault yields exact counts;
+ *      KG triples derive; originalId stable across re-sync (idempotency)
+ *   B. partial snapshot — only history + follow; vault gets correct subset
+ *
+ * Win note: bs3mc has a known NODE_MODULE_VERSION mismatch on this dev box
+ * (Node 22.22.2 ABI v127 vs prebuild ABI v140); test passes on CI Linux
+ * which uses the matched prebuild. See memory pdh-plan-a-android-standalone-
+ * design §"bs3mc NODE_MODULE_VERSION mismatch".
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  LocalVault,
+  generateKeyHex,
+  AdapterRegistry,
+} = require("../../lib");
+const {
+  BilibiliAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+} = require("../../lib/adapters/social-bilibili");
+
+function makeRig() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-int-"));
+  const vault = new LocalVault({ path: path.join(dir, "v.db"), key: generateKeyHex() });
+  vault.open();
+  const registry = new AdapterRegistry({ vault });
+  return { vault, registry, dir };
+}
+
+function cleanup(rig) {
+  if (!rig) return;
+  try { rig.vault.close(); } catch (_e) { /* noop */ }
+  try { fs.rmSync(rig.dir, { recursive: true, force: true }); } catch (_e) { /* noop */ }
+}
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-bilibili.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+function sampleSnapshot(opts = {}) {
+  const include = {
+    history: true,
+    favourite: true,
+    dynamic: true,
+    follow: true,
+    ...opts.include,
+  };
+  const events = [];
+  if (include.history) {
+    events.push({
+      kind: "history",
+      id: "BV1abc",
+      capturedAt: 1715000000000,
+      title: "Rust 异步学习",
+      bvid: "BV1abc",
+      avid: 42,
+      duration: 600,
+      uploader: "技术UP主",
+      uploaderMid: 100,
+      part: "01 介绍",
+    });
+  }
+  if (include.favourite) {
+    events.push({
+      kind: "favourite",
+      id: "fav-BV2def",
+      capturedAt: 1714000000000,
+      title: "前端架构",
+      bvid: "BV2def",
+      folderName: "学习",
+      uploader: "码农UP",
+    });
+  }
+  if (include.dynamic) {
+    events.push({
+      kind: "dynamic",
+      id: "dyn-99",
+      capturedAt: 1713000000000,
+      summary: "今天发了一个新视频",
+      dynamicType: "av",
+      rid: "99",
+      authorMid: 200,
+      authorName: "我关注的UP",
+    });
+  }
+  if (include.follow) {
+    events.push({
+      kind: "follow",
+      id: "follow-300",
+      capturedAt: 1712000000000,
+      mid: 300,
+      uname: "美食UP",
+      face: "https://i0.hdslb.com/300.jpg",
+      sign: "好吃的视频",
+    });
+  }
+  return {
+    schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+    snapshottedAt: 1716000000000,
+    account: { uid: "12345", displayName: "alice" },
+    events,
+  };
+}
+
+describe("Integration — A8 Bilibili snapshot → vault end-to-end", () => {
+  let rig;
+  afterEach(() => { cleanup(rig); rig = null; });
+
+  it("4 kinds ingest into vault with exact entity counts", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, sampleSnapshot());
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+
+    // 3 events (history + favourite + dynamic) + 1 person (follow) +
+    // 2 items (history-video + favourite-video)
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(3);
+    expect(report.entityCounts.persons).toBe(1);
+    expect(report.entityCounts.items).toBe(2);
+
+    // Vault round-trip
+    const events = rig.vault.queryEvents({ limit: 100 });
+    expect(events).toHaveLength(3);
+    const subtypes = events.map((e) => e.subtype).sort();
+    expect(subtypes).toEqual(["browse", "browse", "like"]); // history+dynamic+favourite
+
+    const persons = rig.vault.queryPersons({ limit: 100 });
+    expect(persons).toHaveLength(1);
+    expect(persons[0].names[0]).toBe("美食UP");
+
+    const items = rig.vault.queryItems({ limit: 100 });
+    expect(items).toHaveLength(2);
+    expect(items.map((i) => i.name).sort()).toEqual(["Rust 异步学习", "前端架构"]);
+  });
+
+  it("re-sync is idempotent — same snapshot twice does NOT double entities", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+    const snapshotPath = writeSnapshot(rig.dir, sampleSnapshot());
+
+    // First sync
+    const report1 = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report1.status).toBe("ok");
+
+    // Second sync — same snapshot
+    const report2 = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report2.status).toBe("ok");
+
+    // Stable originalId means re-sync de-dups at raw_events layer.
+    // The person/item entities should remain at 1 / 2 respectively
+    // because their IDs derive from bvid / mid (stable). Events can
+    // legitimately double-write because each "browse" is a separate
+    // occurrence — registry doesn't dedup events.
+    const persons = rig.vault.queryPersons({ limit: 100 });
+    expect(persons).toHaveLength(1);
+
+    const items = rig.vault.queryItems({ limit: 100 });
+    // Items with same bvid produce same ID, so item table stays at 2
+    // (UPSERT semantics via primary-key id).
+    expect(items).toHaveLength(2);
+  });
+
+  it("partial snapshot (history + follow only) yields exact subset", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(
+      rig.dir,
+      sampleSnapshot({ include: { favourite: false, dynamic: false } })
+    );
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(1); // history only
+    expect(report.entityCounts.persons).toBe(1); // follow
+    expect(report.entityCounts.items).toBe(1); // history video
+  });
+
+  it("empty events array → ok status with 0 entity counts", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, {
+      schemaVersion: SNAPSHOT_SCHEMA_VERSION,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("ok");
+    expect(report.entityCounts.events).toBe(0);
+    expect(report.entityCounts.persons).toBe(0);
+    expect(report.entityCounts.items).toBe(0);
+  });
+
+  it("schemaVersion mismatch surfaces in SyncReport.error (not silent)", async () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+
+    const snapshotPath = writeSnapshot(rig.dir, {
+      schemaVersion: 99, // wrong
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const report = await rig.registry.syncAdapter("social-bilibili", {
+      inputPath: snapshotPath,
+    });
+    expect(report.status).toBe("error");
+    expect(String(report.error)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("registry queryable by adapter.name after register()", () => {
+    rig = makeRig();
+    const adapter = new BilibiliAdapter();
+    rig.registry.register(adapter);
+    expect(rig.registry.has("social-bilibili")).toBe(true);
+    expect(rig.registry.list().some((m) => m.name === "social-bilibili")).toBe(true);
+  });
+});

package/__tests__/longtail-adapters.test.js

@@ -84,10 +84,17 @@ describe("XiaohongshuAdapter", () => {
   it("contract conformance", () => {
     const a = new XiaohongshuAdapter({ account: { uid: "u-1" } });
     expect(assertAdapter(a).ok).toBe(true);
+    expect(a.capabilities).toContain("sync:snapshot");
+    expect(a.capabilities).toContain("sync:sqlite");
   });
 
-  it("rejects missing account.uid", () => {
-    expect(() => new XiaohongshuAdapter({ account: {} })).toThrow(/uid/);
+  it("snapshot mode constructs without account.uid (stateless)", () => {
+    // §A8 v0.2: constructor loosened — snapshot mode pulls account from the
+    // snapshot file. Sqlite mode still requires account.uid, checked at sync
+    // time not construction.
+    const a = new XiaohongshuAdapter({});
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.account).toBeNull();
   });
 
   it("sync yields history + likes + favourites", async () => {
@@ -118,17 +125,39 @@ describe("QQAdapter", () => {
     const a = new QQAdapter({ account: { qq: "12345" } });
     expect(assertAdapter(a).ok).toBe(true);
     expect(a.dataDisclosure.legalGate).toBe(true);
+    expect(a.capabilities).toContain("sync:snapshot");
+    expect(a.capabilities).toContain("sync:sqlite");
+  });
+
+  it("snapshot mode constructs without account.qq (stateless)", () => {
+    // §Phase 13.5 v0.2: constructor loosened — snapshot mode pulls account
+    // from the snapshot file. Sqlite mode still requires account.qq, checked
+    // at sync time not construction. Mirror of weibo / bilibili A8 pattern.
+    const a = new QQAdapter({});
+    expect(assertAdapter(a).ok).toBe(true);
+    expect(a.account).toBeNull();
   });
 
-  it("rejects missing account.qq", () => {
-    expect(() => new QQAdapter({ account: {} })).toThrow(/qq/);
+  it("sqlite mode throws at sync time when account.qq missing", async () => {
+    const { dir, dbPath } = tmpDb();
+    try {
+      const a = new QQAdapter({ dbPath, keyProvider: { getKey: async () => "k" } });
+      let threw = null;
+      try {
+        for await (const _r of a.sync()) { /* drain */ }
+      } catch (err) {
+        threw = err;
+      }
+      expect(threw).toBeTruthy();
+      expect(String(threw.message)).toMatch(/account\.qq/);
+    } finally { cleanup(dir); }
   });
 
-  it("authenticate fails without DB", async () => {
+  it("authenticate({}) without inputPath nor dbPath returns NO_INPUT", async () => {
     const a = new QQAdapter({ account: { qq: "12345" }, keyProvider: { getKey: async () => "k" } });
     const r = await a.authenticate();
     expect(r.ok).toBe(false);
-    expect(r.reason).toBe("DB_NOT_PULLED");
+    expect(r.reason).toBe("NO_INPUT");
   });
 
   it("authenticate fails without keyProvider", async () => {
@@ -143,27 +172,44 @@ describe("QQAdapter", () => {
   it("sync yields contact + group + message types", async () => {
     const { dir, dbPath } = tmpDb();
     try {
+      // §Phase 13.5 v0.2 mock — new SQL targets:
+      //   - Friends / friends / tb_recent_contact (probe order)
+      //   - TroopInfoV2
+      //   - sqlite_master LIKE 'mr_friend_%_New'
+      //   - mr_friend_<MD5(peer).upper()>_New
       const mockDriver = makeMockDriver([
-        ["FROM mr_friend", [{ uin: "999", nickname: "好友A", remark: "" }]],
-        ["FROM mr_troop", [{ troop_uin: "888", troop_name: "测试群" }]],
-        ["FROM sqlite_master", [{ name: "msgcsr_friend_999" }]],
-        ["FROM msgcsr_friend_999", [{ msgid: "m1", msg: "你好", time: 1700000000, frienduin: "999", msgtype: 1 }]],
+        ["FROM Friends", [{ uin: "999", nickname: "好友A", remark: "" }]],
+        ["FROM TroopInfoV2", [{ troop_uin: "888", troop_name: "测试群", member_count: 5, owner_uin: "777" }]],
+        ["FROM sqlite_master", [{ name: "mr_friend_ABCDEF1234_New" }]],
+        [
+          "FROM mr_friend_ABCDEF1234_New",
+          [{
+            msgId: "m1", msgtype: -1000, senderuin: "999", time: 1700000000,
+            // msgData is XOR-encrypted bytes; with imei="123456789012345" key,
+            // "hi" encrypts to bytes [0x51, 0x5d] (0x68^0x31=0x59 — actually
+            // depends on imei[0] = '1' = 0x31). Use Buffer for cross-platform.
+            msgData: Buffer.from([0x68 ^ 0x31, 0x69 ^ 0x32]),
+            issend: 0, frienduin: "999", troopuin: null,
+          }],
+        ],
       ]);
       const a = new QQAdapter({
         account: { qq: "12345" },
         dbPath,
-        keyProvider: { getKey: async () => "fakekey" },
+        keyProvider: { getKey: async () => "123456789012345" },
         dbDriverFactory: () => mockDriver,
       });
       const raws = [];
       for await (const r of a.sync()) raws.push(r);
       expect(raws.length).toBe(3); // contact + group + message
-      const contact = raws.find((r) => r.payload.kind === "contact");
-      const group = raws.find((r) => r.payload.kind === "group");
-      const message = raws.find((r) => r.payload.kind === "message");
+      const contact = raws.find((r) => r.kind === "contact");
+      const group = raws.find((r) => r.kind === "group");
+      const message = raws.find((r) => r.kind === "message");
       expect(contact).toBeDefined();
       expect(group).toBeDefined();
       expect(message).toBeDefined();
+      // XOR-decrypt round-trip: bytes(0x68^0x31, 0x69^0x32) XOR "12" = "hi"
+      expect(message.payload.text).toBe("hi");
       for (const r of raws) {
         expect(validateBatch(a.normalize(r)).valid).toBe(true);
       }