@chainlesschain/personal-data-hub 0.4.29 → 0.4.30

package/lib/prompt-builder.js

@@ -48,11 +48,25 @@ const CROSS_APP_HEADER = "CROSS_APP_OVERVIEW (跨 app 汇聚画像 — 各 app
  * Trim an event down to the fields the LLM actually needs. Saves tokens +
  * reduces prompt injection surface (no raw `extra` blob).
  */
+// Local-time "YYYY-MM-DD HH:mm" for the LLM. Passing the raw epoch-ms integer
+// (e.g. 1781706182375) made the model unreliable on "when did I…" questions —
+// it can't dependably convert epoch ms to a date. buildPrompt runs on the
+// user's own machine (cc hub / desktop), so local getters are the user's TZ.
+function fmtLocalDateTime(ms) {
+  const d = new Date(ms);
+  if (!Number.isFinite(d.getTime())) return null;
+  const p = (n) => String(n).padStart(2, "0");
+  return (
+    `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ` +
+    `${p(d.getHours())}:${p(d.getMinutes())}`
+  );
+}
+
 function summarizeEvent(e) {
   const out = {
     id: e.id,
     type: e.subtype,
-    at: e.occurredAt,
+    at: fmtLocalDateTime(e.occurredAt) || e.occurredAt,
     source: e.source && e.source.adapter,
   };
   if (e.actor) out.actor = e.actor;

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@chainlesschain/personal-data-hub",
-  "version": "0.4.29",
+  "version": "0.4.30",
   "description": "Personal Data Hub — UnifiedSchema + validators + KG ingest helpers for the data-back-to-the-individual middleware",
   "type": "commonjs",
   "main": "lib/index.js",
+  "files": [
+    "lib/"
+  ],
   "exports": {
     ".": "./lib/index.js",
     "./constants": "./lib/constants.js",

package/__tests__/adapter-guide.test.js

@@ -1,47 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { getAdapterGuide, ADAPTER_OVERRIDES } = require("../lib/adapter-guide");
-
-describe("adapter-guide", () => {
-  it("wechat-pc guide reflects the 4.0 one-click reality (no manual PyWxDump as primary)", () => {
-    const g = getAdapterGuide("wechat-pc", "device");
-    // primary method is the automatic one-click, not manual decryption
-    const primary = g.methods[0];
-    expect(primary.recommended).toBe(true);
-    expect(primary.label).toMatch(/一键|自动/);
-    expect(primary.steps.join(" ")).toMatch(/一键采集|自动/);
-    // summary mentions the full coverage we now capture
-    expect(g.summary).toMatch(/公众号/);
-    expect(g.summary).toMatch(/朋友圈/);
-    expect(g.summary).toMatch(/收藏/);
-    // manual 3.x path is still offered as a fallback
-    expect(g.methods.some((m) => /3\.x|PyWxDump|手动/.test(m.label + m.steps.join(" ")))).toBe(true);
-  });
-
-  it("the 6 social platforms all have a tailored one-click ADB guide", () => {
-    for (const name of [
-      "social-bilibili",
-      "social-weibo",
-      "social-douyin",
-      "social-xiaohongshu",
-      "social-toutiao",
-      "social-kuaishou",
-    ]) {
-      expect(ADAPTER_OVERRIDES[name]).toBeTruthy();
-      const g = getAdapterGuide(name, "device");
-      const primary = g.methods[0];
-      expect(primary.recommended).toBe(true);
-      // recommended path is root-phone + one-click, not "go log in on the web"
-      expect(primary.label + primary.steps.join(" ")).toMatch(/一键|ADB|USB|root/i);
-    }
-  });
-
-  it("unknown adapter falls back to a category guide without throwing", () => {
-    const g = getAdapterGuide("totally-unknown", "snapshot");
-    expect(g.category).toBe("snapshot");
-    expect(Array.isArray(g.methods)).toBe(true);
-    expect(g.methods.length).toBeGreaterThan(0);
-  });
-});

package/__tests__/adapter-spec.test.js

@@ -1,78 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const { assertAdapter, SENSITIVITY_LEVELS } = require("../lib/adapter-spec");
-const { MockAdapter } = require("../lib/mock-adapter");
-
-describe("assertAdapter", () => {
-  it("accepts a fully-valid adapter (MockAdapter)", () => {
-    const r = assertAdapter(new MockAdapter());
-    expect(r.ok).toBe(true);
-  });
-
-  it("rejects non-object input", () => {
-    expect(assertAdapter(null).ok).toBe(false);
-    expect(assertAdapter(undefined).ok).toBe(false);
-    expect(assertAdapter("oops").ok).toBe(false);
-  });
-
-  it("rejects missing required fields (collects all errors, no throw)", () => {
-    const r = assertAdapter({});
-    expect(r.ok).toBe(false);
-    // Many fields missing — at least name + version + capabilities + dataDisclosure + methods.
-    expect(r.errors.length).toBeGreaterThan(4);
-    expect(r.errors.some((e) => e.includes("name"))).toBe(true);
-    expect(r.errors.some((e) => e.includes("version"))).toBe(true);
-    expect(r.errors.some((e) => e.includes("authenticate"))).toBe(true);
-    expect(r.errors.some((e) => e.includes("sync"))).toBe(true);
-  });
-
-  it("rejects invalid sensitivity", () => {
-    const a = new MockAdapter();
-    a.dataDisclosure = { ...a.dataDisclosure, sensitivity: "extreme" };
-    const r = assertAdapter(a);
-    expect(r.ok).toBe(false);
-    expect(r.errors.some((e) => e.includes("sensitivity"))).toBe(true);
-  });
-
-  it("rejects non-boolean legalGate", () => {
-    const a = new MockAdapter();
-    a.dataDisclosure = { ...a.dataDisclosure, legalGate: "yes" };
-    const r = assertAdapter(a);
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects non-array capabilities", () => {
-    const a = new MockAdapter();
-    a.capabilities = "sync";
-    const r = assertAdapter(a);
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects rateLimits with negative value", () => {
-    const a = new MockAdapter();
-    a.rateLimits = { perMinute: -1 };
-    expect(assertAdapter(a).ok).toBe(false);
-  });
-
-  it("accepts adapter without rateLimits (optional field)", () => {
-    const a = new MockAdapter();
-    delete a.rateLimits;
-    expect(assertAdapter(a).ok).toBe(true);
-  });
-
-  it("rejects non-function authenticate / sync / normalize / healthCheck", () => {
-    const a = new MockAdapter();
-    a.authenticate = "not a function";
-    expect(assertAdapter(a).ok).toBe(false);
-
-    const b = new MockAdapter();
-    b.normalize = 42;
-    expect(assertAdapter(b).ok).toBe(false);
-  });
-
-  it("SENSITIVITY_LEVELS lists low/medium/high", () => {
-    expect(SENSITIVITY_LEVELS).toEqual(["low", "medium", "high"]);
-  });
-});

package/__tests__/adapters/ai-chat-cookie-capture-spec.test.js

@@ -1,211 +0,0 @@
-"use strict";
-
-import { describe, it, expect } from "vitest";
-
-const {
-  COOKIE_SPEC_VERSION,
-  KNOWN_VENDORS,
-  COOKIE_CAPTURE_SPECS,
-  getSpec,
-  listVendors,
-  classifyProbedCookies,
-  validateCookieCaptureSpec,
-  _internal,
-} = require("../../lib/adapters/ai-chat-history/cookie-capture-spec");
-
-describe("cookie-capture-spec — Phase 10.3.1 matrix", () => {
-  it("exposes a positive integer COOKIE_SPEC_VERSION", () => {
-    expect(Number.isInteger(COOKIE_SPEC_VERSION)).toBe(true);
-    expect(COOKIE_SPEC_VERSION).toBeGreaterThanOrEqual(1);
-  });
-
-  it("KNOWN_VENDORS contains exactly the 9 wired vendors", () => {
-    expect(KNOWN_VENDORS).toEqual([
-      "deepseek",
-      "kimi",
-      "tongyi",
-      "zhipu",
-      "hunyuan",
-      "qianfan",
-      "coze",
-      "dreamina",
-      "doubao",
-    ]);
-    // Defensive — frozen so contributors don't accidentally mutate at runtime.
-    expect(Object.isFrozen(KNOWN_VENDORS)).toBe(true);
-  });
-
-  it("ships 9 specs, one per KNOWN_VENDORS entry, no duplicates", () => {
-    expect(COOKIE_CAPTURE_SPECS.length).toBe(KNOWN_VENDORS.length);
-    const seen = new Set();
-    for (const s of COOKIE_CAPTURE_SPECS) {
-      expect(KNOWN_VENDORS).toContain(s.vendor);
-      expect(seen.has(s.vendor)).toBe(false);
-      seen.add(s.vendor);
-    }
-  });
-
-  it("validates the shipped spec set without errors", () => {
-    const r = validateCookieCaptureSpec(undefined, { throwOnError: false });
-    expect(r.errors).toEqual([]);
-    expect(r.ok).toBe(true);
-  });
-
-  it("each loginUrl host matches at least one cookieDomains entry", () => {
-    for (const s of COOKIE_CAPTURE_SPECS) {
-      const host = new URL(s.loginUrl).host;
-      const matched = s.cookieDomains.some((d) =>
-        d.startsWith(".") ? host.endsWith(d.slice(1)) : host === d,
-      );
-      expect({ vendor: s.vendor, host, matched }).toEqual({ vendor: s.vendor, host, matched: true });
-    }
-  });
-
-  it("each spec has non-empty requiredCookies + postLoginPathHints + positive maxAge", () => {
-    for (const s of COOKIE_CAPTURE_SPECS) {
-      expect(Array.isArray(s.requiredCookies)).toBe(true);
-      expect(s.requiredCookies.length).toBeGreaterThan(0);
-      expect(Array.isArray(s.postLoginPathHints)).toBe(true);
-      expect(s.postLoginPathHints.length).toBeGreaterThan(0);
-      expect(Number.isInteger(s.cookieMaxAgeHintDays)).toBe(true);
-      expect(s.cookieMaxAgeHintDays).toBeGreaterThan(0);
-      expect(typeof s.notes).toBe("string");
-      expect(s.notes.length).toBeGreaterThan(0);
-    }
-  });
-
-  it("getSpec returns the right spec for a known vendor and null for unknown", () => {
-    const ds = getSpec("deepseek");
-    expect(ds).toBeTruthy();
-    expect(ds.vendor).toBe("deepseek");
-    expect(getSpec("notarealvendor")).toBeNull();
-    expect(getSpec("")).toBeNull();
-    expect(getSpec(undefined)).toBeNull();
-    expect(getSpec(null)).toBeNull();
-  });
-
-  it("listVendors returns a copy (mutation does not affect KNOWN_VENDORS)", () => {
-    const arr = listVendors();
-    expect(arr).toEqual([...KNOWN_VENDORS]);
-    arr.push("hacked");
-    expect(KNOWN_VENDORS.includes("hacked")).toBe(false);
-  });
-});
-
-describe("classifyProbedCookies — required vs optional vs missing", () => {
-  it("returns ok=true when all required cookies present (object input)", () => {
-    const r = classifyProbedCookies("deepseek", {
-      userToken: "abc",
-      "intercom-session-deepseek": "xyz",
-    });
-    expect(r.ok).toBe(true);
-    expect(r.foundRequired).toEqual(["userToken"]);
-    expect(r.missingRequired).toEqual([]);
-    expect(r.foundOptional).toEqual(["intercom-session-deepseek"]);
-  });
-
-  it("returns ok=false when a required cookie is missing", () => {
-    const r = classifyProbedCookies("kimi", { refresh_token: "rt", session_id: "sid" });
-    expect(r.ok).toBe(false);
-    expect(r.missingRequired).toEqual(["access_token"]);
-    expect(r.foundOptional.sort()).toEqual(["refresh_token", "session_id"]);
-  });
-
-  it("accepts Electron Cookie[] shape (array of { name, value })", () => {
-    const r = classifyProbedCookies("zhipu", [
-      { name: "chatglm_token", value: "tok" },
-      { name: "cgsessionid", value: "sid" },
-      { name: "unrelated", value: "x" },
-    ]);
-    expect(r.ok).toBe(true);
-    expect(r.foundRequired).toEqual(["chatglm_token"]);
-    expect(r.foundOptional).toContain("cgsessionid");
-  });
-
-  it("accepts raw 'k=v; k=v' string (web-shell paste fallback)", () => {
-    const raw = "sessionid=abc; sid_guard=xyz; passport_csrf_token=csrf;  ;junk";
-    const r = classifyProbedCookies("doubao", raw);
-    expect(r.ok).toBe(true);
-    expect(r.foundRequired).toEqual(["sessionid"]);
-    expect(r.foundOptional.sort()).toEqual(["passport_csrf_token", "sid_guard"]);
-  });
-
-  it("string parser tolerates values containing '=' (e.g. base64)", () => {
-    // sessionid is base64 with '=' padding; only the FIRST '=' is the delimiter.
-    const raw = "sessionid=YWJjZGVmZ2g=; sid_guard=v1=";
-    const r = classifyProbedCookies("coze", raw);
-    expect(r.ok).toBe(true);
-    expect(r.foundRequired).toEqual(["sessionid"]);
-    // raw cookie value must be preserved verbatim including the trailing '='
-    const jar = _internal._normalizeCookieJar(raw);
-    expect(jar.sessionid).toBe("YWJjZGVmZ2g=");
-  });
-
-  it("empty string / null / undefined / wrong type all produce ok=false", () => {
-    for (const input of ["", null, undefined, 42, true]) {
-      const r = classifyProbedCookies("doubao", input);
-      expect(r.ok).toBe(false);
-      expect(r.missingRequired).toEqual(["sessionid"]);
-    }
-  });
-
-  it("returns UNKNOWN_VENDOR reason for an unregistered vendor name", () => {
-    const r = classifyProbedCookies("notarealvendor", { anything: "x" });
-    expect(r.ok).toBe(false);
-    expect(r.reason).toBe("UNKNOWN_VENDOR");
-  });
-
-  it("treats empty-string cookie value as missing (not present)", () => {
-    const r = classifyProbedCookies("deepseek", { userToken: "" });
-    expect(r.ok).toBe(false);
-    expect(r.foundRequired).toEqual([]);
-    expect(r.missingRequired).toEqual(["userToken"]);
-  });
-});
-
-describe("validateCookieCaptureSpec — defensive guard catches malformed specs", () => {
-  it("flags unknown vendor", () => {
-    const { ok, errors } = validateCookieCaptureSpec(
-      [{ ...COOKIE_CAPTURE_SPECS[0], vendor: "ghostvendor" }],
-      { throwOnError: false },
-    );
-    expect(ok).toBe(false);
-    expect(errors.join(" ")).toMatch(/unknown vendor/);
-  });
-
-  it("flags loginUrl host not matching any cookieDomain", () => {
-    const broken = {
-      ...COOKIE_CAPTURE_SPECS[0],
-      loginUrl: "https://malicious.example.com/",
-    };
-    const { ok, errors } = validateCookieCaptureSpec([broken], { throwOnError: false });
-    expect(ok).toBe(false);
-    expect(errors.join(" ")).toMatch(/does not match any cookieDomain/);
-  });
-
-  it("flags empty requiredCookies / postLoginPathHints / invalid maxAge", () => {
-    const broken = {
-      ...COOKIE_CAPTURE_SPECS[0],
-      requiredCookies: [],
-      postLoginPathHints: [],
-      cookieMaxAgeHintDays: 0,
-    };
-    const { ok, errors } = validateCookieCaptureSpec([broken], { throwOnError: false });
-    expect(ok).toBe(false);
-    const joined = errors.join(" ");
-    expect(joined).toMatch(/requiredCookies/);
-    expect(joined).toMatch(/postLoginPathHints/);
-    expect(joined).toMatch(/cookieMaxAgeHintDays/);
-  });
-
-  it("flags duplicate vendor entries", () => {
-    const dup = [COOKIE_CAPTURE_SPECS[0], { ...COOKIE_CAPTURE_SPECS[0] }];
-    const { ok, errors } = validateCookieCaptureSpec(dup, { throwOnError: false });
-    expect(ok).toBe(false);
-    expect(errors.join(" ")).toMatch(/duplicate vendor/);
-  });
-
-  it("throws by default when malformed (no opts)", () => {
-    expect(() => validateCookieCaptureSpec([{ vendor: "ghost" }])).toThrow(/Invalid cookie capture spec/);
-  });
-});

package/__tests__/adapters/ai-chat-health-checker.test.js

@@ -1,262 +0,0 @@
-"use strict";
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-const {
-  createAIChatHealthChecker,
-  DEFAULT_INTERVAL_MS,
-  DEFAULT_FIRST_RUN_DELAY_MS,
-} = require("../../lib/adapters/ai-chat-history/health-checker");
-
-// ─── fakes ────────────────────────────────────────────────────────────────
-
-function makeFakeAccountsStore({ initial = {} } = {}) {
-  const store = new Map(Object.entries(initial));
-  return {
-    get: vi.fn(async (v) => store.get(v) || null),
-    put: vi.fn(async (v, e) => store.set(v, e)),
-    delete: vi.fn(async (v) => store.delete(v)),
-    list: vi.fn(async () => Array.from(store.values())),
-    _store: store,
-  };
-}
-
-function makeFakeAdapter({ behaviors = {} } = {}) {
-  // behaviors = { vendor: ({ok, reason?, throw?: msg}) }
-  return {
-    registerVendor: vi.fn(async (vendor, _cookies) => {
-      const b = behaviors[vendor];
-      if (!b) return { ok: true, userId: "u_" + vendor };
-      if (b.throw) throw new Error(b.throw);
-      return b;
-    }),
-  };
-}
-
-function makeFakeTimers() {
-  // Deterministic timer dispatcher we can step through. We track scheduled
-  // callbacks + their delays in a queue and let tests `flush` them in order.
-  const scheduled = [];
-  let _now = 0;
-  let _id = 0;
-  const setTimeout = (fn, ms) => {
-    const id = ++_id;
-    scheduled.push({ id, type: "timeout", fireAt: _now + ms, fn });
-    return id;
-  };
-  const setInterval = (fn, ms) => {
-    const id = ++_id;
-    scheduled.push({ id, type: "interval", fireAt: _now + ms, ms, fn });
-    return id;
-  };
-  const clearTimeout = (id) => {
-    const i = scheduled.findIndex((s) => s.id === id);
-    if (i >= 0) scheduled.splice(i, 1);
-  };
-  const clearInterval = clearTimeout;
-  async function advance(ms) {
-    _now += ms;
-    while (true) {
-      const due = scheduled
-        .filter((s) => s.fireAt <= _now)
-        .sort((a, b) => a.fireAt - b.fireAt);
-      if (due.length === 0) break;
-      const next = due[0];
-      const idx = scheduled.indexOf(next);
-      scheduled.splice(idx, 1);
-      if (next.type === "interval") {
-        scheduled.push({ ...next, fireAt: next.fireAt + next.ms });
-      }
-      await next.fn();
-      // Flush any fire-and-forget microtasks the callback kicked off
-      // (runOnce returns a promise; the callback doesn't await it).
-      await new Promise((r) => setImmediate(r));
-    }
-  }
-  return {
-    setTimeout, setInterval, clearTimeout, clearInterval,
-    clock: () => _now,
-    advance,
-    _scheduled: scheduled,
-  };
-}
-
-// ─── construction guards ─────────────────────────────────────────────────
-
-describe("createAIChatHealthChecker — guards", () => {
-  it("throws when accountsStore.list missing", () => {
-    expect(() => createAIChatHealthChecker({ accountsStore: {}, vendorAdapter: { registerVendor: () => {} } })).toThrow(/accountsStore.list/);
-  });
-  it("throws when accountsStore.put missing", () => {
-    expect(() => createAIChatHealthChecker({ accountsStore: { list: () => [] }, vendorAdapter: { registerVendor: () => {} } })).toThrow(/accountsStore.put/);
-  });
-  it("throws when vendorAdapter.registerVendor missing", () => {
-    expect(() => createAIChatHealthChecker({ accountsStore: makeFakeAccountsStore() })).toThrow(/vendorAdapter.registerVendor/);
-  });
-});
-
-// ─── runOnce behavior ────────────────────────────────────────────────────
-
-describe("runOnce — health classification", () => {
-  let timers;
-  beforeEach(() => {
-    timers = makeFakeTimers();
-  });
-
-  it("marks vendors ok when adapter returns ok=true", async () => {
-    const store = makeFakeAccountsStore({
-      initial: {
-        deepseek: { vendor: "deepseek", cookies: { userToken: "x" }, cookieSpecVersion: 1 },
-        kimi: { vendor: "kimi", cookies: { access_token: "y" }, cookieSpecVersion: 1 },
-      },
-    });
-    const adapter = makeFakeAdapter();
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, _deps: timers,
-    });
-    const r = await hc.runOnce();
-    expect(r).toMatchObject({ checked: 2, ok: 2, failed: 0, mismatch: 0 });
-    expect(store._store.get("deepseek").lastHealth.ok).toBe(true);
-    expect(store._store.get("kimi").lastHealth.ok).toBe(true);
-  });
-
-  it("marks vendors failed when adapter returns ok=false (with reason)", async () => {
-    const store = makeFakeAccountsStore({
-      initial: { deepseek: { vendor: "deepseek", cookies: {}, cookieSpecVersion: 1 } },
-    });
-    const adapter = makeFakeAdapter({
-      behaviors: { deepseek: { ok: false, reason: "COOKIE_EXPIRED" } },
-    });
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, _deps: timers,
-    });
-    const r = await hc.runOnce();
-    expect(r).toMatchObject({ checked: 1, failed: 1, ok: 0 });
-    expect(store._store.get("deepseek").lastHealth).toMatchObject({
-      ok: false, reason: "COOKIE_EXPIRED",
-    });
-  });
-
-  it("marks SPEC_VERSION_MISMATCH when entry.cookieSpecVersion < specVersion", async () => {
-    const store = makeFakeAccountsStore({
-      initial: { deepseek: { vendor: "deepseek", cookies: { x: "y" }, cookieSpecVersion: 0 } },
-    });
-    const adapter = makeFakeAdapter();
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, specVersion: 2, _deps: timers,
-    });
-    const r = await hc.runOnce();
-    expect(r).toMatchObject({ checked: 1, mismatch: 1, ok: 0, failed: 0 });
-    expect(store._store.get("deepseek").lastHealth).toMatchObject({
-      ok: false, reason: "SPEC_VERSION_MISMATCH",
-    });
-    // Adapter was NOT called because the version gate fired first
-    expect(adapter.registerVendor).not.toHaveBeenCalled();
-  });
-
-  it("captures ADAPTER_THREW when registerVendor rejects", async () => {
-    const store = makeFakeAccountsStore({
-      initial: { deepseek: { vendor: "deepseek", cookies: { x: "y" }, cookieSpecVersion: 1 } },
-    });
-    const adapter = makeFakeAdapter({ behaviors: { deepseek: { throw: "net down" } } });
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, _deps: timers,
-    });
-    const r = await hc.runOnce();
-    expect(r).toMatchObject({ checked: 1, failed: 1 });
-    expect(store._store.get("deepseek").lastHealth).toMatchObject({
-      ok: false, reason: "ADAPTER_THREW",
-    });
-  });
-
-  it("skips a run if previous one is still in flight", async () => {
-    const store = makeFakeAccountsStore({
-      initial: { deepseek: { vendor: "deepseek", cookies: {}, cookieSpecVersion: 1 } },
-    });
-    let release;
-    const adapter = {
-      registerVendor: vi.fn(() => new Promise((resolve) => {
-        release = () => resolve({ ok: true, userId: "u" });
-      })),
-    };
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, _deps: timers,
-    });
-    const p1 = hc.runOnce();
-    const r2 = await hc.runOnce();
-    expect(r2.skipped).toBe(true);
-    release();
-    await p1;
-  });
-
-  it("returns 0 counts on empty accounts list", async () => {
-    const hc = createAIChatHealthChecker({
-      accountsStore: makeFakeAccountsStore(),
-      vendorAdapter: makeFakeAdapter(),
-      _deps: timers,
-    });
-    const r = await hc.runOnce();
-    expect(r).toMatchObject({ checked: 0, ok: 0, failed: 0, mismatch: 0 });
-  });
-});
-
-// ─── start / stop / interval scheduling ──────────────────────────────────
-
-describe("start / stop / interval", () => {
-  let timers, store, adapter;
-  beforeEach(() => {
-    timers = makeFakeTimers();
-    store = makeFakeAccountsStore({
-      initial: { deepseek: { vendor: "deepseek", cookies: { userToken: "x" }, cookieSpecVersion: 1 } },
-    });
-    adapter = makeFakeAdapter();
-  });
-
-  it("first run happens after firstRunDelayMs (30s default), then interval (6h)", async () => {
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter,
-      intervalMs: 6 * 3600_000, firstRunDelayMs: 30_000,
-      _deps: timers,
-    });
-    hc.start();
-    expect(hc.status().started).toBe(true);
-    // 10s in — nothing has fired yet
-    await timers.advance(10_000);
-    expect(adapter.registerVendor).not.toHaveBeenCalled();
-    // 30s mark — first run fires
-    await timers.advance(20_000);
-    expect(adapter.registerVendor).toHaveBeenCalledTimes(1);
-    // Another 6h — interval run #1
-    await timers.advance(6 * 3600_000);
-    expect(adapter.registerVendor).toHaveBeenCalledTimes(2);
-  });
-
-  it("start is idempotent — second call returns false", () => {
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, _deps: timers,
-    });
-    expect(hc.start()).toBe(true);
-    expect(hc.start()).toBe(false);
-  });
-
-  it("stop clears pending first-run + interval", async () => {
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, firstRunDelayMs: 30_000, _deps: timers,
-    });
-    hc.start();
-    hc.stop();
-    expect(hc.status().started).toBe(false);
-    // 60s in — nothing fires since we stopped
-    await timers.advance(60_000);
-    expect(adapter.registerVendor).not.toHaveBeenCalled();
-  });
-
-  it("uses default 6h interval + 30s delay when not specified", () => {
-    const hc = createAIChatHealthChecker({
-      accountsStore: store, vendorAdapter: adapter, _deps: timers,
-    });
-    const s = hc.status();
-    expect(s.intervalMs).toBe(DEFAULT_INTERVAL_MS);
-    expect(s.firstRunDelayMs).toBe(DEFAULT_FIRST_RUN_DELAY_MS);
-  });
-});