@chainlesschain/personal-data-hub 0.2.0 → 0.2.2

package/__tests__/social-adapters.test.js

@@ -37,9 +37,47 @@ describe("BilibiliAdapter", () => {
     expect(a.extractMode).toBe("device-pull");
   });
 
-  it("rejects missing account.uid", () => {
-    expect(() => new BilibiliAdapter({})).toThrow();
-    expect(() => new BilibiliAdapter({ account: {} })).toThrow(/uid/);
+  it("accepts stateless construction (snapshot mode added in A8)", () => {
+    // Before A8: constructor required opts.account.uid. After A8 the adapter
+    // is stateless when running snapshot mode (in-APK Android cc reads a JSON
+    // produced by the phone). Sqlite mode still needs account.uid but the
+    // check moved into _syncViaSqlite where it actually matters.
+    expect(() => new BilibiliAdapter({})).not.toThrow();
+    expect(() => new BilibiliAdapter({ account: {} })).not.toThrow();
+    expect(() => new BilibiliAdapter()).not.toThrow();
+  });
+
+  it("sqlite mode rejects missing account.uid at sync time", async () => {
+    const a = new BilibiliAdapter({ dbPath: "/tmp/bili.db" });
+    // Path-existence check happens before account.uid validation, so we
+    // exercise the guard via dbPath=null + account=null which falls to
+    // "sync needs inputPath OR dbPath" first. Use a real-looking dbPath
+    // with no account to surface the account.uid throw deterministically.
+    const fs = require("node:fs");
+    const path = require("node:path");
+    const os = require("node:os");
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-no-acct-"));
+    const dbPath = path.join(dir, "bili.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const b = new BilibiliAdapter({
+        dbPath,
+        dbDriverFactory: () => () => ({
+          prepare: () => ({ all: () => [] }),
+          close() {},
+        }),
+      });
+      let threw = null;
+      try {
+        for await (const _r of b.sync()) { /* drain */ }
+      } catch (err) {
+        threw = err;
+      }
+      expect(threw).toBeTruthy();
+      expect(String(threw.message)).toMatch(/account\.uid/);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
   });
 
   it("sync yields history + favourite records via mocked driver", async () => {
@@ -83,26 +121,34 @@ describe("BilibiliAdapter", () => {
     }
   });
 
-  it("idle when DB path missing", async () => {
+  it("throws when neither inputPath nor dbPath provided (A8: surface config errors)", async () => {
+    // Before A8: sync silently yielded 0 if dbPath missing — masked typos and
+    // misconfigured callers. After A8 we throw so callers see the problem.
     const a = new BilibiliAdapter({ account: { uid: "1234" } });
-    const raws = [];
-    for await (const r of a.sync()) raws.push(r);
-    expect(raws).toHaveLength(0);
+    let threw = null;
+    try {
+      for await (const _r of a.sync()) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/inputPath|dbPath/);
   });
 
-  it("normalize captures bvid/avid/uploader into extra", async () => {
+  it("normalize captures bvid/avid/uploader into extra (flat payload, A8 shape)", async () => {
     const a = new BilibiliAdapter({ account: { uid: "1234" } });
     const raw = {
       adapter: "social-bilibili",
-      originalId: "history-1",
+      kind: "history",
+      originalId: "bilibili:history:BV1abc",
       capturedAt: 1700000000000,
       payload: {
         kind: "history",
-        row: {
-          id: 1, bvid: "BV1abc", avid: "1234",
-          title: "Test", view_at: 1700000000,
-          uploader: "UpA", duration: 300,
-        },
+        title: "Test",
+        bvid: "BV1abc",
+        avid: "1234",
+        uploader: "UpA",
+        duration: 300,
       },
     };
     const batch = a.normalize(raw);
@@ -110,6 +156,9 @@ describe("BilibiliAdapter", () => {
     expect(batch.events[0].extra.avid).toBe("1234");
     expect(batch.events[0].extra.uploader).toBe("UpA");
     expect(batch.events[0].extra.duration).toBe(300);
+    // A8: history also yields an item entity (video) for KG linkage
+    expect(batch.items).toHaveLength(1);
+    expect(batch.items[0].extra.bvid).toBe("BV1abc");
   });
 });
 

package/__tests__/social-bilibili-snapshot.test.js

@@ -0,0 +1,278 @@
+"use strict";
+
+import { describe, it, expect, beforeEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  BilibiliAdapter,
+  SNAPSHOT_SCHEMA_VERSION,
+  VALID_KINDS,
+} = require("../lib/adapters/social-bilibili");
+const { validateBatch } = require("../lib/batch");
+
+// A8 v0.1 (2026-05-22) — snapshot-mode tests, mirroring system-data-android.
+//
+// Why a separate file? `social-adapters.test.js` covers the legacy sqlite
+// path (Phase 7.5 device-pull). Snapshot mode is a brand-new ingestion path
+// driven by in-APK Android cc reading JSON from the phone's own WebView+OkHttp
+// pipeline. Keeping tests separated makes it obvious which mode a regression
+// belongs to.
+
+function writeSnapshot(dir, snapshot) {
+  const p = path.join(dir, "social-bilibili.json");
+  fs.writeFileSync(p, JSON.stringify(snapshot), "utf-8");
+  return p;
+}
+
+describe("BilibiliAdapter snapshot mode", () => {
+  let tmpDir;
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "bili-snap-"));
+  });
+
+  it("exports SNAPSHOT_SCHEMA_VERSION = 1 + 4 VALID_KINDS", () => {
+    expect(SNAPSHOT_SCHEMA_VERSION).toBe(1);
+    expect(VALID_KINDS).toEqual(["history", "favourite", "dynamic", "follow"]);
+  });
+
+  it("authenticate(inputPath) ok when readable", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BilibiliAdapter();
+    const res = await a.authenticate({ inputPath: p });
+    expect(res.ok).toBe(true);
+    expect(res.mode).toBe("snapshot-file");
+  });
+
+  it("authenticate(inputPath) fails when path unreadable", async () => {
+    const a = new BilibiliAdapter();
+    const res = await a.authenticate({ inputPath: path.join(tmpDir, "missing.json") });
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("INPUT_PATH_UNREADABLE");
+  });
+
+  it("authenticate() with neither inputPath nor dbPath returns NO_INPUT", async () => {
+    const a = new BilibiliAdapter();
+    const res = await a.authenticate({});
+    expect(res.ok).toBe(false);
+    expect(res.reason).toBe("NO_INPUT");
+  });
+
+  it("rejects schemaVersion mismatch", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 99,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BilibiliAdapter();
+    let threw = null;
+    try {
+      for await (const _r of a.sync({ inputPath: p })) { /* drain */ }
+    } catch (err) {
+      threw = err;
+    }
+    expect(threw).toBeTruthy();
+    expect(String(threw.message)).toMatch(/schemaVersion mismatch/);
+  });
+
+  it("empty events array yields nothing (no crash)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(0);
+  });
+
+  it("yields all 4 kinds + normalize produces valid batches", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: 1716000000000,
+      account: { uid: "12345", displayName: "alice" },
+      events: [
+        {
+          kind: "history",
+          id: "BV1abc",
+          capturedAt: 1715000000000,
+          title: "Rust 异步学习",
+          bvid: "BV1abc",
+          avid: 42,
+          duration: 600,
+          uploader: "技术UP主",
+          uploaderMid: 100,
+          part: "01 介绍",
+        },
+        {
+          kind: "favourite",
+          id: "fav-BV2def",
+          capturedAt: 1714000000000,
+          title: "前端架构",
+          bvid: "BV2def",
+          folderName: "学习",
+          uploader: "码农UP",
+        },
+        {
+          kind: "dynamic",
+          id: "dyn-99",
+          capturedAt: 1713000000000,
+          summary: "今天发了一个新视频",
+          dynamicType: "video",
+          rid: 99,
+          authorMid: 200,
+          authorName: "我关注的UP",
+        },
+        {
+          kind: "follow",
+          id: "follow-300",
+          capturedAt: 1712000000000,
+          mid: 300,
+          uname: "美食UP",
+          face: "https://i0.hdslb.com/...",
+          sign: "好吃的视频",
+        },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+
+    expect(raws).toHaveLength(4);
+    expect(raws.map((r) => r.kind).sort()).toEqual([
+      "dynamic",
+      "favourite",
+      "follow",
+      "history",
+    ]);
+    // Stable originalId format
+    expect(raws.find((r) => r.kind === "history").originalId).toBe("bilibili:history:BV1abc");
+    expect(raws.find((r) => r.kind === "favourite").originalId).toBe("bilibili:favourite:fav-BV2def");
+    expect(raws.find((r) => r.kind === "dynamic").originalId).toBe("bilibili:dynamic:dyn-99");
+    expect(raws.find((r) => r.kind === "follow").originalId).toBe("bilibili:follow:follow-300");
+
+    // Normalize each + validate
+    for (const raw of raws) {
+      const batch = a.normalize(raw);
+      const v = validateBatch(batch);
+      expect(v.valid).toBe(true);
+
+      if (raw.kind === "history") {
+        expect(batch.events[0].subtype).toBe("browse");
+        expect(batch.events[0].extra.bvid).toBe("BV1abc");
+        expect(batch.events[0].extra.duration).toBe(600);
+        expect(batch.items).toHaveLength(1);
+        expect(batch.items[0].name).toBe("Rust 异步学习");
+      } else if (raw.kind === "favourite") {
+        expect(batch.events[0].subtype).toBe("like");
+        expect(batch.events[0].extra.folderName).toBe("学习");
+        expect(batch.items).toHaveLength(1);
+      } else if (raw.kind === "dynamic") {
+        expect(batch.events[0].subtype).toBe("browse");
+        expect(batch.events[0].extra.dynamicType).toBe("video");
+        expect(batch.events[0].extra.authorName).toBe("我关注的UP");
+      } else if (raw.kind === "follow") {
+        // Follow yields a person, not an event
+        expect(batch.events).toHaveLength(0);
+        expect(batch.persons).toHaveLength(1);
+        expect(batch.persons[0].names[0]).toBe("美食UP");
+        expect(batch.persons[0].identifiers["bilibili-mid"]).toEqual(["300"]);
+      }
+    }
+  });
+
+  it("per-kind include filter (e.g. include.follow=false drops follows)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        { kind: "history", id: "h1", title: "x" },
+        { kind: "follow", id: "f1", mid: 1, uname: "u" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, include: { follow: false } })) {
+      raws.push(r);
+    }
+    expect(raws).toHaveLength(1);
+    expect(raws[0].kind).toBe("history");
+  });
+
+  it("limit caps emission", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        { kind: "history", id: "1", title: "a" },
+        { kind: "history", id: "2", title: "b" },
+        { kind: "history", id: "3", title: "c" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p, limit: 2 })) raws.push(r);
+    expect(raws).toHaveLength(2);
+  });
+
+  it("skips unknown kinds (forward-compat with future event types)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        { kind: "history", id: "1", title: "ok" },
+        { kind: "fancy-new-kind-from-future", id: "x", data: "?" },
+        { kind: "favourite", id: "f", title: "also ok" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(2);
+    expect(raws.map((r) => r.kind).sort()).toEqual(["favourite", "history"]);
+  });
+
+  it("uses fallback originalId when event.id absent (no crash, still ingestable)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      events: [
+        // Missing id — adapter should derive from bvid/mid/rid or generate fallback
+        { kind: "history", bvid: "BV1xyz", title: "no-id" },
+        { kind: "follow", mid: 999, uname: "with-mid-no-id" },
+        { kind: "dynamic", summary: "no id no rid" },
+      ],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(3);
+    // history derives from bvid
+    expect(raws[0].originalId).toBe("bilibili:history:BV1xyz");
+    // follow derives from mid
+    expect(raws[1].originalId).toBe("bilibili:follow:999");
+    // dynamic with no id/bvid/mid/rid → fallback unknown- prefix
+    expect(raws[2].originalId).toMatch(/^bilibili:dynamic:unknown-/);
+  });
+
+  it("snapshot account propagates to payload (Path Y can re-attribute later)", async () => {
+    const p = writeSnapshot(tmpDir, {
+      schemaVersion: 1,
+      snapshottedAt: Date.now(),
+      account: { uid: "55555", displayName: "tester" },
+      events: [{ kind: "history", id: "1", title: "x" }],
+    });
+    const a = new BilibiliAdapter();
+    const raws = [];
+    for await (const r of a.sync({ inputPath: p })) raws.push(r);
+    expect(raws).toHaveLength(1);
+    expect(raws[0].payload.account.uid).toBe("55555");
+  });
+});

package/__tests__/wechat-adapter.test.js

@@ -331,6 +331,29 @@ describe("normalizeWeChatContact", () => {
     const b = normalizeWeChatContact({});
     expect(b.persons).toHaveLength(0);
   });
+
+  // sjqz parity audit follow-up (post-Phase 12.6.10) — classify
+  // 公众号 / Official Accounts (gh_*) as merchant subtype so the Ask
+  // flow / EntityResolver can filter them out of human contacts.
+  it("gh_* username → subtype merchant (公众号 / Official Account)", () => {
+    const b = normalizeWeChatContact({
+      username: "gh_abc123def",
+      nickname: "某品牌官方",
+      type: 3,
+    });
+    expect(b.persons).toHaveLength(1);
+    expect(b.persons[0].subtype).toBe("merchant");
+    expect(b.persons[0].identifiers.wechatId).toBe("gh_abc123def");
+  });
+
+  it("regular wxid_* → subtype contact (default)", () => {
+    const b = normalizeWeChatContact({
+      username: "wxid_realfriend",
+      nickname: "好友",
+      type: 1,
+    });
+    expect(b.persons[0].subtype).toBe("contact");
+  });
 });
 
 // ─── WechatAdapter contract + sync flow ──────────────────────────────────
@@ -441,6 +464,101 @@ describe("WechatAdapter.sync with mocked DB reader", () => {
     }
   });
 
+  // sjqz parity audit follow-up — fetchContacts must exclude
+   // @stranger and fake_* by default (vault pollution prevention).
+  it("fetchContacts excludes @stranger and fake_* by default", async () => {
+    // Pure DI smoke — capture the SQL passed to .prepare() to verify the
+    // junk filter is in the query. We mock just enough of better-sqlite3's
+    // shape: db.prepare(sql) → { all(limit) → rows }, exec, pragma.
+    const seenSql = [];
+    const fakeDriver = function Database(_path, _opts) {
+      return {
+        pragma: () => undefined,
+        exec: () => undefined,
+        prepare(sql) {
+          seenSql.push(sql);
+          return {
+            all: () => {
+              if (sql.startsWith("PRAGMA table_info")) {
+                return [
+                  { name: "username" },
+                  { name: "alias" },
+                  { name: "nickname" },
+                  { name: "conRemark" },
+                  { name: "type" },
+                ];
+              }
+              if (sql.startsWith("SELECT count")) return [{ n: 5 }];
+              if (sql.includes("FROM rcontact")) return [];
+              return [];
+            },
+            get: () => ({ n: 5 }),
+          };
+        },
+        close: () => undefined,
+      };
+    };
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "wechat-junkfilt-"));
+    const dbPath = path.join(dir, "EnMicroMsg.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const reader = new WeChatDBReader({
+        dbPath,
+        keyProvider: { getKey: async () => "0".repeat(64) },
+        driver: fakeDriver,
+      });
+      await reader.open();
+      reader.fetchContacts({ limit: 100 });
+      const contactsSql = seenSql.find((s) => s.includes("FROM rcontact"));
+      expect(contactsSql).toBeDefined();
+      expect(contactsSql).toMatch(/NOT LIKE '%@stranger'/);
+      expect(contactsSql).toMatch(/NOT LIKE 'fake_%'/);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("fetchContacts with includeJunk:true drops the filter (forensic mode)", async () => {
+    const seenSql = [];
+    const fakeDriver = function Database() {
+      return {
+        pragma: () => undefined,
+        exec: () => undefined,
+        prepare(sql) {
+          seenSql.push(sql);
+          return {
+            all: () => {
+              if (sql.startsWith("PRAGMA table_info")) {
+                return ["username", "alias", "nickname", "conRemark", "type"].map((name) => ({ name }));
+              }
+              if (sql.startsWith("SELECT count")) return [{ n: 5 }];
+              return [];
+            },
+            get: () => ({ n: 5 }),
+          };
+        },
+        close: () => undefined,
+      };
+    };
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "wechat-incljunk-"));
+    const dbPath = path.join(dir, "EnMicroMsg.db");
+    fs.writeFileSync(dbPath, "fake");
+    try {
+      const reader = new WeChatDBReader({
+        dbPath,
+        keyProvider: { getKey: async () => "0".repeat(64) },
+        driver: fakeDriver,
+      });
+      await reader.open();
+      reader.fetchContacts({ limit: 100, includeJunk: true });
+      const contactsSql = seenSql.find((s) => s.includes("FROM rcontact"));
+      expect(contactsSql).toBeDefined();
+      expect(contactsSql).not.toMatch(/NOT LIKE/);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("idle no-op when DB path missing", async () => {
     const a = new WechatAdapter({
       account: { uin: "self123" },

package/lib/adapters/ai-chat-history/ai-chat-adapter.js

@@ -45,6 +45,7 @@ const { SPEC: hunyuanSpec } = require("./vendors/hunyuan");
 const { SPEC: qianfanSpec } = require("./vendors/qianfan");
 const { SPEC: cozeSpec } = require("./vendors/coze");
 const { SPEC: dreaminaSpec } = require("./vendors/dreamina");
+const { SPEC: doubaoSpec } = require("./vendors/doubao");
 
 const DEFAULT_VENDOR_SPECS = Object.freeze({
   deepseek: deepseekSpec,
@@ -55,6 +56,7 @@ const DEFAULT_VENDOR_SPECS = Object.freeze({
   qianfan: qianfanSpec,
   coze: cozeSpec,
   dreamina: dreaminaSpec,
+  doubao: doubaoSpec,
 });
 
 class AIChatHistoryAdapter {
@@ -186,13 +188,19 @@ class AIChatHistoryAdapter {
   /**
    * Stream conversation + message envelopes across all configured vendors.
    *
-   * Yields raw events of two shapes:
-   *   { kind: "conversation", vendor, conversation: RawConversation }
-   *   { kind: "message",      vendor, message: RawMessage }
+   * Yields AdapterRegistry-compliant envelopes:
+   *   { originalId, capturedAt, payload: { kind, vendor, conversation|message } }
    *
-   * The registry calls `normalize(raw)` per yielded event. We deliberately
-   * keep one Raw per yield (rather than batching) so a slow vendor doesn't
-   * block faster ones at the registry boundary.
+   * The inner `payload.kind` distinguishes:
+   *   - "conversation"           → emit Topic + vendor Person (no Event yet)
+   *   - "message"                → emit Event + items + vendor Person
+   *   - "vendor-not-wired"       → no-op normalize (Phase 10.1 stub trace)
+   *   - "vendor-cookie-expired"  → no-op normalize (401/403 trace)
+   *   - "vendor-rate-limited"    → no-op normalize (429 trace after retries)
+   *
+   * The registry calls `normalize(raw)` per yielded envelope. One yield per
+   * conversation/message keeps registry batches small so a slow vendor
+   * doesn't block faster ones at the registry boundary.
    *
    * @param {object} [opts]
    * @param {string[]} [opts.vendors]   restrict to a subset
@@ -216,28 +224,54 @@ class AIChatHistoryAdapter {
 
       try {
         for await (const conv of spec.listConversations(ctx, { since: vendorWatermark })) {
-          yield { kind: "conversation", vendor, conversation: conv };
+          yield {
+            originalId: `${vendor}:conv:${conv.originalId}`,
+            capturedAt: Number(conv.updatedAt) || Number(conv.createdAt) || Date.now(),
+            payload: { kind: "conversation", vendor, conversation: conv },
+          };
 
           for await (const msg of spec.listMessages(ctx, conv.originalId, {})) {
-            yield { kind: "message", vendor, message: msg };
+            yield {
+              originalId: `${vendor}:msg:${msg.originalId}`,
+              capturedAt: Number(msg.createdAt) || Date.now(),
+              payload: { kind: "message", vendor, message: msg },
+            };
           }
         }
       } catch (err) {
+        const traceCapturedAt = Date.now();
         if (err instanceof NotImplementedYetError) {
           this._logger.warn(
             `[ai-chat] vendor=${vendor} not wired (Phase 10.2+ work): ${err.message}`,
           );
-          yield { kind: "vendor-not-wired", vendor, error: err.code };
+          yield {
+            originalId: `${vendor}:trace:not-wired:${traceCapturedAt}`,
+            capturedAt: traceCapturedAt,
+            payload: { kind: "vendor-not-wired", vendor, error: err.code },
+          };
           continue;
         }
         if (err instanceof CookieExpiredError) {
           this._logger.warn(`[ai-chat] vendor=${vendor} cookie expired: ${err.message}`);
-          yield { kind: "vendor-cookie-expired", vendor, error: err.code };
+          yield {
+            originalId: `${vendor}:trace:cookie-expired:${traceCapturedAt}`,
+            capturedAt: traceCapturedAt,
+            payload: { kind: "vendor-cookie-expired", vendor, error: err.code },
+          };
           continue;
         }
         if (err instanceof RateLimitedError) {
           this._logger.warn(`[ai-chat] vendor=${vendor} rate limited: ${err.message}`);
-          yield { kind: "vendor-rate-limited", vendor, error: err.code, retryAfterMs: err.retryAfterMs };
+          yield {
+            originalId: `${vendor}:trace:rate-limited:${traceCapturedAt}`,
+            capturedAt: traceCapturedAt,
+            payload: {
+              kind: "vendor-rate-limited",
+              vendor,
+              error: err.code,
+              retryAfterMs: err.retryAfterMs,
+            },
+          };
           continue;
         }
         throw err;
@@ -256,14 +290,19 @@ class AIChatHistoryAdapter {
     if (!raw || typeof raw !== "object") {
       return { events: [], persons: [], places: [], items: [], topics: [] };
     }
+    // Registry-compliant envelopes wrap kind inside payload. Adapter-internal
+    // tests (Phase 10.1) sometimes pass the inner shape directly — accept
+    // both for forward compat.
+    const inner = raw.payload && typeof raw.payload === "object" ? raw.payload : raw;
+    const kind = inner.kind;
 
-    if (raw.kind === "vendor-not-wired") {
+    if (kind === "vendor-not-wired" || kind === "vendor-cookie-expired" || kind === "vendor-rate-limited") {
       // Nothing to write; the warning was already logged by sync().
       return { events: [], persons: [], places: [], items: [], topics: [] };
     }
 
-    if (raw.kind === "conversation") {
-      const conv = raw.conversation;
+    if (kind === "conversation") {
+      const conv = inner.conversation;
       const spec = this._vendorSpecs[conv.vendor];
       const displayName = spec ? spec.displayName : conv.vendor;
       return {
@@ -275,8 +314,8 @@ class AIChatHistoryAdapter {
       };
     }
 
-    if (raw.kind === "message") {
-      const msg = raw.message;
+    if (kind === "message") {
+      const msg = inner.message;
       const spec = this._vendorSpecs[msg.vendor];
       const displayName = spec ? spec.displayName : msg.vendor;
       return {