chainlesschain 0.162.102 → 0.162.103

package/src/commands/__tests__/hub-health.test.js

@@ -0,0 +1,105 @@
+/**
+ * `cc hub health` — focused unit tests for the --quick (minimal hub) path.
+ *
+ * Why this test exists: `cc hub health` defaults to the FULL hub because its
+ * job is to verify hub init wired every component (llm / kgSink / ragSink) —
+ * a minimal hub leaves those null on purpose, so reporting them as down would
+ * be a false negative, not a faster check. `--quick` opts into a vault-only
+ * probe on the minimal hub (skips the 77-adapter registry + sink wiring) and
+ * must mark the other components "not probed" rather than failing them. If
+ * that distinction regresses, `--quick` would either go slow again or start
+ * lying about component health. This suite is the canary.
+ *
+ * Uses the `_getHub` injection seam — no real vault / no spinner side effects.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { _internal } from "../hub.js";
+
+const { cmdHealth } = _internal;
+
+let exitSpy, logSpy, out;
+
+beforeEach(() => {
+  exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {});
+  out = [];
+  logSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
+    out.push(args.join(" "));
+  });
+});
+
+afterEach(() => {
+  exitSpy.mockRestore();
+  logSpy.mockRestore();
+});
+
+function fullHub() {
+  return {
+    minimal: false,
+    vault: { db: {}, schemaVersion: () => 4 },
+    llm: { name: "ollama:qwen2.5", isLocal: true },
+    kgSink: {},
+    ragSink: {},
+  };
+}
+
+function minimalHub() {
+  return {
+    minimal: true,
+    vault: { db: {}, schemaVersion: () => 4 },
+    llm: null,
+    kgSink: null,
+    ragSink: null,
+  };
+}
+
+function parseJson() {
+  return JSON.parse(out.join("\n"));
+}
+
+describe("cc hub health — default (full) vs --quick (minimal)", () => {
+  it("default probes all four components with real ok states", async () => {
+    const stub = vi.fn(async () => fullHub());
+    await cmdHealth({ json: true, _getHub: stub });
+    const o = parseJson();
+    expect(stub).toHaveBeenCalledTimes(1);
+    expect(o.quick).toBe(false);
+    expect(o.vault.ok).toBe(true);
+    expect(o.vault.schemaVersion).toBe(4);
+    expect(o.llm).toEqual({ ok: true, isLocal: true, name: "ollama:qwen2.5" });
+    expect(o.kgSink).toEqual({ ok: true });
+    expect(o.ragSink).toEqual({ ok: true });
+  });
+
+  it("--quick reports vault only; llm/kgSink/ragSink marked not probed (NOT down)", async () => {
+    await cmdHealth({
+      json: true,
+      quick: true,
+      _getHub: async () => minimalHub(),
+    });
+    const o = parseJson();
+    expect(o.quick).toBe(true);
+    expect(o.vault.ok).toBe(true);
+    // The key correctness property: not-probed, never { ok: false }.
+    expect(o.llm).toEqual({ probed: false });
+    expect(o.kgSink).toEqual({ probed: false });
+    expect(o.ragSink).toEqual({ probed: false });
+    expect(o.llm.ok).toBeUndefined();
+  });
+
+  it("--quick human output notes the skipped components", async () => {
+    await cmdHealth({ quick: true, _getHub: async () => minimalHub() });
+    const text = out.join("\n");
+    expect(text).toMatch(/vault\s+schema=4/);
+    expect(text).toContain("not probed");
+    expect(text).toContain("--quick");
+  });
+
+  it("default human output lists llm/kgSink/ragSink", async () => {
+    await cmdHealth({ _getHub: async () => fullHub() });
+    const text = out.join("\n");
+    expect(text).toContain("llm");
+    expect(text).toContain("kgSink");
+    expect(text).toContain("ragSink");
+  });
+});

package/src/commands/__tests__/hub-stats.test.js

@@ -0,0 +1,106 @@
+/**
+ * `cc hub stats` — focused unit tests for the minimal-vs-full hub selection.
+ *
+ * Why this test exists: `cc hub stats` defaults to the MINIMAL hub so a quick
+ * "how many rows do I have" check doesn't pay to instantiate the full
+ * 77-adapter registry + KG/RAG sinks + email-account auto-load. The adapter
+ * list + resolved LLM are only built when the caller passes `--full` (or via
+ * the standalone `cc hub list-adapters`). If that wiring regresses, every
+ * `cc hub stats` call silently goes back to a slow full-hub init. This suite
+ * is the canary.
+ *
+ * Uses the `_getHub` injection seam — no real vault / no spinner side effects.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { _internal } from "../hub.js";
+
+const { cmdStats } = _internal;
+
+let exitSpy, logSpy, jsonOut;
+
+beforeEach(() => {
+  exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {});
+  jsonOut = [];
+  logSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
+    jsonOut.push(args.join(" "));
+  });
+});
+
+afterEach(() => {
+  exitSpy.mockRestore();
+  logSpy.mockRestore();
+});
+
+function minimalHub() {
+  return {
+    minimal: true,
+    hubDir: "/tmp/hub",
+    vault: {
+      stats: () => ({ events: 3, persons: 1, places: 0, items: 6, topics: 2 }),
+    },
+    registry: null,
+    llm: null,
+  };
+}
+
+function fullHub() {
+  return {
+    minimal: false,
+    hubDir: "/tmp/hub",
+    vault: {
+      stats: () => ({ events: 3, persons: 1, places: 0, items: 6, topics: 2 }),
+    },
+    registry: {
+      list: () => [
+        { name: "wechat", version: "0.1.0" },
+        { name: "email-imap", version: "0.2.0" },
+      ],
+    },
+    llm: { name: "ollama:qwen2.5", isLocal: true },
+  };
+}
+
+function parseJson() {
+  return JSON.parse(jsonOut.join("\n"));
+}
+
+describe("cc hub stats — minimal vs full hub selection", () => {
+  it("default (no --full) builds the MINIMAL hub: null adapters, minimal flag", async () => {
+    const stub = vi.fn(async () => minimalHub());
+    await cmdStats({ json: true, _getHub: stub });
+    const out = parseJson();
+    expect(stub).toHaveBeenCalledTimes(1);
+    expect(out.minimal).toBe(true);
+    expect(out.adapters).toBeNull();
+    expect(out.llm).toBeNull();
+    expect(out.vault.items).toBe(6);
+    expect(out.hubDir).toBe("/tmp/hub");
+  });
+
+  it("--full builds the full hub: adapters listed, llm resolved, minimal false", async () => {
+    const stub = vi.fn(async () => fullHub());
+    await cmdStats({ json: true, full: true, _getHub: stub });
+    const out = parseJson();
+    expect(out.minimal).toBe(false);
+    expect(Array.isArray(out.adapters)).toBe(true);
+    expect(out.adapters).toHaveLength(2);
+    expect(out.llm).toEqual({ name: "ollama:qwen2.5", isLocal: true });
+  });
+
+  it("human (non-JSON) minimal output points to --full / list-adapters", async () => {
+    await cmdStats({ _getHub: async () => minimalHub() });
+    const text = jsonOut.join("\n");
+    expect(text).toMatch(/events:\s+3/);
+    expect(text).toContain("cc hub list-adapters");
+    expect(text).toContain("cc hub stats --full");
+  });
+
+  it("human full output lists adapter names + versions", async () => {
+    await cmdStats({ full: true, _getHub: async () => fullHub() });
+    const text = jsonOut.join("\n");
+    expect(text).toContain("adapters (2)");
+    expect(text).toContain("wechat");
+    expect(text).toContain("email-imap");
+  });
+});

package/src/commands/hub.js

@@ -173,12 +173,28 @@ async function cmdRetrieveContext(question, options) {
 
 async function cmdStats(options) {
   try {
-    const hub = await getHub();
+    // Default to the minimal hub: stats' core payload (vault row counts +
+    // hubDir) only needs the vault, so the full 77-adapter registry + KG/RAG
+    // sinks + email-account auto-load is wasted work for a quick `cc hub
+    // stats`. Pass --full to also list registered adapters and the resolved
+    // LLM, which require the full hub init. (The adapter list is also
+    // available standalone via `cc hub list-adapters`.) getHubMinimal()
+    // transparently returns the full hub if one was already built this
+    // process, so --full is only needed on a cold stats call. Tests stub
+    // via _getHub.
+    const wantFull = options.full === true;
+    const hub = options._getHub
+      ? await options._getHub()
+      : wantFull
+        ? await getHub()
+        : await getHubMinimal();
+    const adapters = hub.registry ? hub.registry.list() : null;
     const out = {
       vault: hub.vault.stats(),
-      adapters: hub.registry.list(),
+      adapters,
       hubDir: hub.hubDir,
       llm: hub.llm ? { name: hub.llm.name, isLocal: hub.llm.isLocal } : null,
+      minimal: !!hub.minimal,
     };
     if (options.json) {
       printJson(out);
@@ -190,9 +206,17 @@ async function cmdStats(options) {
       logger.log(`  places:   ${v.places}`);
       logger.log(`  items:    ${v.items}`);
       logger.log(`  topics:   ${v.topics}`);
-      logger.log(chalk.bold(`\nadapters (${out.adapters.length}):`));
-      for (const a of out.adapters) {
-        logger.log(`  ${chalk.cyan(a.name)} v${a.version}`);
+      if (out.adapters) {
+        logger.log(chalk.bold(`\nadapters (${out.adapters.length}):`));
+        for (const a of out.adapters) {
+          logger.log(`  ${chalk.cyan(a.name)} v${a.version}`);
+        }
+      } else {
+        logger.log(
+          chalk.gray(
+            "\nadapters: (run `cc hub stats --full` or `cc hub list-adapters`)",
+          ),
+        );
       }
       logger.log(chalk.gray(`\nhubDir: ${out.hubDir}`));
       if (out.llm) {
@@ -200,6 +224,8 @@ async function cmdStats(options) {
           ? chalk.green("[local]")
           : chalk.yellow("[remote]");
         logger.log(chalk.gray(`llm: ${out.llm.name} ${tag}`));
+      } else if (out.minimal) {
+        logger.log(chalk.gray("llm: (run `cc hub stats --full` to resolve)"));
       } else {
         logger.log(chalk.yellow("llm: (none)"));
       }
@@ -213,18 +239,39 @@ async function cmdStats(options) {
 
 async function cmdHealth(options) {
   try {
-    const hub = await getHub();
+    // Full hub is the default: health's whole job is verifying that hub init
+    // wired every component (llm / kgSink / ragSink), which a minimal hub
+    // deliberately leaves null — reporting those as ✗ would be a false
+    // negative, not a faster check. `--quick` opts into a vault-only probe
+    // on the minimal hub (skips the 77-adapter registry + sink wiring) for
+    // when you just need "is the vault openable / what schema". Tests stub
+    // via _getHub.
+    const quick = options.quick === true;
+    const hub = options._getHub
+      ? await options._getHub()
+      : quick
+        ? await getHubMinimal()
+        : await getHub();
     const out = {
+      quick,
       vault: {
         ok: !!hub.vault.db,
         schemaVersion: hub.vault.schemaVersion(),
       },
-      llm: hub.llm
-        ? { ok: true, isLocal: hub.llm.isLocal, name: hub.llm.name }
-        : { ok: false, reason: "LLM unavailable" },
-      kgSink: { ok: !!hub.kgSink },
-      ragSink: { ok: !!hub.ragSink },
     };
+    if (quick) {
+      // Minimal hub intentionally has no llm / kgSink / ragSink — mark them
+      // "not probed" rather than reporting a misleading down state.
+      out.llm = { probed: false };
+      out.kgSink = { probed: false };
+      out.ragSink = { probed: false };
+    } else {
+      out.llm = hub.llm
+        ? { ok: true, isLocal: hub.llm.isLocal, name: hub.llm.name }
+        : { ok: false, reason: "LLM unavailable" };
+      out.kgSink = { ok: !!hub.kgSink };
+      out.ragSink = { ok: !!hub.ragSink };
+    }
     if (options.json) {
       printJson(out);
     } else {
@@ -232,17 +279,25 @@ async function cmdHealth(options) {
       logger.log(
         `${mark(out.vault.ok)} vault    schema=${out.vault.schemaVersion}`,
       );
-      logger.log(
-        `${mark(out.llm.ok)} llm      ${out.llm.name || out.llm.reason}${
-          out.llm.ok
-            ? out.llm.isLocal
-              ? chalk.green(" [local]")
-              : chalk.yellow(" [remote]")
-            : ""
-        }`,
-      );
-      logger.log(`${mark(out.kgSink.ok)} kgSink`);
-      logger.log(`${mark(out.ragSink.ok)} ragSink`);
+      if (quick) {
+        logger.log(
+          chalk.gray(
+            "· llm / kgSink / ragSink not probed (run without --quick)",
+          ),
+        );
+      } else {
+        logger.log(
+          `${mark(out.llm.ok)} llm      ${out.llm.name || out.llm.reason}${
+            out.llm.ok
+              ? out.llm.isLocal
+                ? chalk.green(" [local]")
+                : chalk.yellow(" [remote]")
+              : ""
+          }`,
+        );
+        logger.log(`${mark(out.kgSink.ok)} kgSink`);
+        logger.log(`${mark(out.ragSink.ok)} ragSink`);
+      }
     }
   } catch (err) {
     fail(null, err, options.json);
@@ -468,7 +523,11 @@ async function cmdRederive(options) {
 
 async function cmdQueryEvents(options) {
   try {
-    const hub = await getHub();
+    // Read-only vault query — needs no adapters / sinks / llm. Minimal hub
+    // skips the 77-adapter registry build (and is crash-resilient to a
+    // partial pdh install). getHubMinimal() returns the full hub if one was
+    // already built this process, so the vault instance is identical.
+    const hub = await getHubMinimal();
     const q = {};
     if (options.subtype) q.subtype = options.subtype;
     if (options.since) q.since = Number(options.since);
@@ -528,7 +587,8 @@ function importEventsInto(vault, events) {
       imported += 1;
     } catch (e) {
       failed += 1;
-      if (errors.length < 10) errors.push({ id: ev && ev.id, error: e.message });
+      if (errors.length < 10)
+        errors.push({ id: ev && ev.id, error: e.message });
     }
   }
   return { ok: failed === 0, imported, failed, errors };
@@ -536,7 +596,8 @@ function importEventsInto(vault, events) {
 
 async function cmdExportEvents(options) {
   try {
-    const hub = await (options._getHub || getHub)();
+    // Vault-only raw-event export — no adapters needed, use the minimal hub.
+    const hub = await (options._getHub || getHubMinimal)();
     const all = exportAllEvents(hub.vault);
     if (options.output) {
       require("fs").writeFileSync(options.output, JSON.stringify(all), "utf-8");
@@ -566,7 +627,8 @@ async function cmdImportEvents(options) {
     if (!Array.isArray(events)) {
       throw new Error("import-events: expected a JSON array of events");
     }
-    const hub = await (options._getHub || getHub)();
+    // Vault-only idempotent upsert — no adapters needed, use the minimal hub.
+    const hub = await (options._getHub || getHubMinimal)();
     const result = importEventsInto(hub.vault, events);
     if (options.json) {
       jsonAndExit(result);
@@ -585,7 +647,8 @@ async function cmdImportEvents(options) {
 // (Android LocalCcRunner.searchEvents calls this; CI smoke too).
 async function cmdSearchEvents(options) {
   try {
-    const hub = await getHub();
+    // Read-only vault FTS search — vault-only, use the minimal hub.
+    const hub = await getHubMinimal();
     const q = {};
     if (options.q) q.q = String(options.q);
     if (options.adapter) q.adapter = options.adapter;
@@ -628,7 +691,8 @@ async function cmdSearchEvents(options) {
 
 async function cmdFacetCounts(options) {
   try {
-    const hub = await getHub();
+    // Read-only vault facet aggregation — vault-only, use the minimal hub.
+    const hub = await getHubMinimal();
     const q = {};
     if (options.q) q.q = String(options.q);
     if (options.since) q.since = Number(options.since);
@@ -657,7 +721,8 @@ async function cmdFacetCounts(options) {
 
 async function cmdRecentAudit(options) {
   try {
-    const hub = await getHub();
+    // Read-only vault audit log query — vault-only, use the minimal hub.
+    const hub = await getHubMinimal();
     const q = {};
     if (options.since) q.since = Number(options.since);
     if (options.action) q.action = options.action;
@@ -722,7 +787,8 @@ async function cmdEventDetail(eventId, options) {
     process.exit(1);
   }
   try {
-    const hub = await getHub();
+    // Read-only single-event lookup — vault-only, use the minimal hub.
+    const hub = await getHubMinimal();
     const event = hub.vault.getEvent(eventId);
     if (!event) {
       const result = { found: false, eventId };
@@ -774,7 +840,8 @@ async function cmdExport(options) {
   try {
     const fs = await import("node:fs");
     const path = await import("node:path");
-    const hub = await getHub();
+    // Vault-file snapshot copy — vault-only, use the minimal hub.
+    const hub = await getHubMinimal();
     const src = hub.vault.path;
     if (!src) throw new Error("vault path unavailable (hub not initialized?)");
 
@@ -2606,14 +2673,24 @@ export function registerHubCommand(program) {
 
   hub
     .command("stats")
-    .description("Vault row counts + registered adapter list + hub paths")
+    .description(
+      "Vault row counts + hub paths (use --full to also list adapters + LLM)",
+    )
     .option("--json", "Output JSON")
+    .option(
+      "--full",
+      "Include registered adapter list + resolved LLM (loads the full hub)",
+    )
     .action(cmdStats);
 
   hub
     .command("health")
     .description("Component health: vault / llm / kgSink / ragSink")
     .option("--json", "Output JSON")
+    .option(
+      "--quick",
+      "Vault-only probe via the minimal hub (skips llm/kgSink/ragSink wiring)",
+    )
     .action(cmdHealth);
 
   hub
@@ -3175,6 +3252,8 @@ export function registerHubCommand(program) {
 export const _internal = {
   cmdAsk,
   cmdRetrieveContext,
+  cmdStats,
+  cmdHealth,
   parsePositiveInt,
   cmdAIChatList,
   cmdAIChatLogin,

package/src/gateways/ws/personal-data-hub-protocol.js

@@ -30,9 +30,22 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
-import pdhPkg from "@chainlesschain/personal-data-hub";
-
-const { ingestSystemDataAndroidSnapshot } = pdhPkg;
+// Lazily import the pdh package the first time the system-data-android
+// ingest topic is actually used. This module is pulled in by the
+// agent/chat/serve/ui runtime chain at startup (ws-server →
+// message-dispatcher → here), so a top-level static import would force the
+// whole pdh graph to load on every `cc` invocation — and a partial/corrupt
+// pdh install would brick unrelated commands. See the matching rationale in
+// personal-data-hub-wiring.js.
+let _ingestSnapshotFn = null;
+async function ingestSystemDataAndroidSnapshot(hub, snapshot) {
+  if (!_ingestSnapshotFn) {
+    const pdhMod = await import("@chainlesschain/personal-data-hub");
+    const pdhPkg = pdhMod.default || pdhMod;
+    _ingestSnapshotFn = pdhPkg.ingestSystemDataAndroidSnapshot;
+  }
+  return _ingestSnapshotFn(hub, snapshot);
+}
 
 /**
  * If the caller didn't pass `inputPath`, try to pull a snapshot for

package/src/lib/personal-data-hub-wiring.js

@@ -29,11 +29,20 @@ import { mkdirSync } from "node:fs";
 // Hub package is CJS; in ESM we default-import then destructure (Node 22
 // won't let us name-import a CJS module unless it ships a separate ESM
 // shim, which we don't).
-import hub from "@chainlesschain/personal-data-hub";
-import wechatAdapterModule from "@chainlesschain/personal-data-hub/adapters/wechat";
-const { bootstrapWechatAdapter, probeWeChatEnv } = wechatAdapterModule;
-const {
-  LocalVault,
+// PDH is loaded LAZILY (not a top-level static import) so that merely
+// importing this wiring module — which happens on EVERY `cc` invocation,
+// because index.js statically pulls in commands/hub.js (getHub) AND the
+// agent/chat/serve/ui runtime chain (ws pdh-protocol → this wiring) — does
+// NOT eagerly evaluate the entire personal-data-hub adapter graph. Wins:
+//   • Robustness: a partial/corrupt pdh install (e.g. an interrupted
+//     `npm i -g` that left adapter files unwritten) no longer bricks
+//     unrelated commands like `cc -v` with a cryptic ERR_MODULE_NOT_FOUND.
+//     pdh only loads when a `cc hub …` / web-shell hub topic actually runs.
+//   • Startup cost: non-hub commands skip loading 50+ adapter modules.
+// The bindings below are populated by ensurePdhLoaded(), which initHub() and
+// initHubMinimal() await before touching any of them.
+let bootstrapWechatAdapter, probeWeChatEnv;
+let LocalVault,
   AdapterRegistry,
   AnalysisEngine,
   MockAdapter,
@@ -124,8 +133,125 @@ const {
   EntityResolverEmbeddingStage,
   EntityResolverLLMStage,
   runAnalysisSkill,
-  ANALYSIS_SKILL_NAMES,
-} = hub;
+  ANALYSIS_SKILL_NAMES;
+
+let _pdhLoadPromise = null;
+/**
+ * Lazily import the personal-data-hub package + wechat adapter and populate
+ * the module-level binding holders above. Memoized so concurrent
+ * getHub()/getHubMinimal() callers share one load. Must be awaited by any
+ * code path that uses a pdh binding (initHub / initHubMinimal).
+ */
+function ensurePdhLoaded() {
+  if (!_pdhLoadPromise) {
+    _pdhLoadPromise = (async () => {
+      const hubMod = await import("@chainlesschain/personal-data-hub");
+      const hub = hubMod.default || hubMod;
+      // Composed specifier dodges vite/vitest static import-analysis of
+      // subpath exports (same trick as loadAIChatHealthChecker below).
+      const wechatSpec =
+        "@chainlesschain/personal-data-hub" + "/adapters/wechat";
+      const waMod = await import(wechatSpec);
+      const wechatAdapterModule = waMod.default || waMod;
+      ({ bootstrapWechatAdapter, probeWeChatEnv } = wechatAdapterModule);
+      ({
+        LocalVault,
+        AdapterRegistry,
+        AnalysisEngine,
+        MockAdapter,
+        OllamaClient,
+        CcKgSink,
+        CcRagSink,
+        FileKeyProvider,
+        generateKeyHex,
+        EmailAdapter,
+        AlipayBillAdapter,
+        SystemDataAndroidAdapter,
+        BrowserHistoryChromeAdapter,
+        BrowserHistoryEdgeAdapter,
+        VSCodeAdapter,
+        WinRecentAdapter,
+        GitActivityAdapter,
+        ShellHistoryAdapter,
+        LocalFilesAdapter,
+        BilibiliAdapter,
+        WeiboAdapter,
+        ZhihuAdapter,
+        DoubanAdapter,
+        BossZhipinAdapter,
+        CsdnAdapter,
+        DongchediAdapter,
+        TianyanchaAdapter,
+        DouyinAdapter,
+        XiaohongshuAdapter,
+        ToutiaoAdapter,
+        KuaishouAdapter,
+        GenshinAdapter,
+        HonorOfKingsAdapter,
+        ZuoyebangAdapter,
+        AlipayAdapter,
+        HuaweiLearningAdapter,
+        QQAdapter,
+        WeChatPcAdapter,
+        QQPcAdapter,
+        AppleHealthAdapter,
+        NeteaseMusicAdapter,
+        KugouMusicAdapter,
+        QQMusicAdapter,
+        XimalayaAdapter,
+        FanqieReadingAdapter,
+        QimaoReadingAdapter,
+        JoyrunAdapter,
+        KeepAdapter,
+        DidiConsumerAdapter,
+        MercedesMeAdapter,
+        IqiyiVideoAdapter,
+        TencentVideoAdapter,
+        XiguaVideoAdapter,
+        WeReadAdapter,
+        WpsDocAdapter,
+        TencentDocsAdapter,
+        BaiduNetdiskAdapter,
+        CamScannerDocAdapter,
+        IXiamenAdapter,
+        MeiyouAdapter,
+        TaxAdapter,
+        CmbcBankAdapter,
+        BocBankAdapter,
+        BankcommBankAdapter,
+        IcbcBankAdapter,
+        DcepAdapter,
+        Tmri12123Adapter,
+        DingTalkPcAdapter,
+        FeishuPcAdapter,
+        WeWorkPcAdapter,
+        BaiduMapAdapter,
+        TencentMapAdapter,
+        JdAdapter,
+        MeituanAdapter,
+        ElemeAdapter,
+        PinduoduoAdapter,
+        DianpingAdapter,
+        XianyuAdapter,
+        VipshopAdapter,
+        Train12306Adapter,
+        TaobaoAdapter,
+        CtripAdapter,
+        TongchengAdapter,
+        DidiAdapter,
+        AmapAdapter,
+        TelegramAdapter,
+        WhatsAppAdapter,
+        EntityResolver,
+        EntityResolverEmbeddingStage,
+        EntityResolverLLMStage,
+        runAnalysisSkill,
+        ANALYSIS_SKILL_NAMES,
+      } = hub);
+    })();
+  }
+  return _pdhLoadPromise;
+}
 import {
   readFileSync,
   writeFileSync,
@@ -209,6 +335,7 @@ export function resolveHubDir() {
 }
 
 async function initHub() {
+  await ensurePdhLoaded();
   // Phase 1c: hoisted so the hub-level `bilibiliAdbSync` method can reuse
   // the same bridge instance the system-data-android adapter wires below.
   // Single bridge per hub keeps `bilibili.cookies` extension state /
@@ -1490,6 +1617,7 @@ let _hubMinimal = null;
 let _hubMinimalInitPromise = null;
 
 async function initHubMinimal() {
+  await ensurePdhLoaded();
   const hubDir = resolveHubDir();
   mkdirSync(hubDir, { recursive: true });
   mkdirSync(join(hubDir, "keys"), { recursive: true });