@chainlesschain/personal-data-hub 0.2.3 → 0.3.0

package/lib/analysis.js

@@ -21,7 +21,7 @@
 
 "use strict";
 
-const { parseQuery } = require("./query-parser");
+const { parseQuery, extractEntityTerm } = require("./query-parser");
 const {
   buildPrompt,
   parseCitations,
@@ -33,6 +33,34 @@ const { toError } = require("./adapter-spec");
 const DEFAULT_MAX_FACTS = 80;
 const DEFAULT_MAX_QUERY_LIMIT = 200;
 
+// intent=latest hard cap when no time window is set. "最近的订单" / "最新消息"
+// want the newest 1-3 rows, not 80 — freeing prompt budget lets the LLM
+// actually read the row content instead of skimming. Memory:
+// pdh_analysis_engine_intent_routing.md. When the user also gives a time
+// window ("最近 30 天的消费") we treat it as list-with-window and fall
+// through to the default broader path — see _gatherFacts.
+const LATEST_INTENT_FACT_LIMIT = 3;
+
+// intent=list FTS5 augmentation cap. When the question carries a probable
+// entity-name ("提到王老板的消息", "苹果的订单") we run an extra
+// vault.searchEvents(q=term) and append non-duplicate hits to FACTS. Cap
+// at 10 so a popular term ("订单") can't drown out the adapter+time slice
+// the user explicitly asked for. Stays additive (never replaces events).
+const LIST_INTENT_FTS_LIMIT = 10;
+
+// intent=sum-amount routing — the only event subtypes that carry an
+// amount field worth summing. Order keeps "order" first because it's the
+// most common shopping flow (taobao/jd/meituan/pdd all map to it). When
+// the user asks "总共花了多少" we only want events from this set; pulling
+// `message` / `visit` / `browse` would waste prompt budget on rows the
+// LLM cannot use to compute a sum.
+const SUM_AMOUNT_SUBTYPES = ["order", "payment", "transfer", "income"];
+// Per-subtype query cap divider — split the effMaxQueryLimit across the
+// 4 subtypes so a popular `payment` slice can't crowd out `transfer`.
+// Floor at 20 so per-call small-model budget (effMaxQueryLimit=50 →
+// 12) doesn't starve any single subtype.
+const SUM_AMOUNT_MIN_PER_SUBTYPE = 20;
+
 class AnalysisEngine {
   /**
    * @param {object} opts
@@ -72,6 +100,8 @@ class AnalysisEngine {
    * @param {boolean} [options.acceptNonLocal=false]  required true for cloud LLMs
    * @param {number} [options.now]
    * @param {boolean} [options.skipAudit=false]
+   * @param {number} [options.maxFacts]                per-call override of constructor `maxFacts` (e.g. on-device 1.5B model wants ~20)
+   * @param {number} [options.maxQueryLimit]           per-call override of constructor `maxQueryLimit`
    * @returns {Promise<AskResult>}
    *
    * @typedef {object} AskResult
@@ -99,8 +129,34 @@ class AnalysisEngine {
     const startedAt = Date.now();
     const parsed = parseQuery(question, { now: options.now });
 
+    // Per-call budget overrides — on-device small models (Qwen2.5-1.5B etc.)
+    // need a much tighter prompt than desktop 7B+. Fall back to constructor
+    // defaults if not passed. Non-positive overrides are ignored.
+    const effMaxFacts =
+      Number.isInteger(options.maxFacts) && options.maxFacts > 0
+        ? options.maxFacts
+        : this.maxFacts;
+    const effMaxQueryLimit =
+      Number.isInteger(options.maxQueryLimit) && options.maxQueryLimit > 0
+        ? options.maxQueryLimit
+        : this.maxQueryLimit;
+
     // Gather facts from the vault.
-    const facts = this._gatherFacts(parsed);
+    const facts = this._gatherFacts(parsed, { maxFacts: effMaxFacts, maxQueryLimit: effMaxQueryLimit });
+
+    // Telemetry: prove the budget is reaching the engine. Goes to stderr so
+    // the Android side's stderrBuilder + logcat can surface it.
+    // Grep: `adb logcat | grep PDH-ASK`.
+    try {
+      process.stderr.write(
+        `[PDH-ASK] ask effMaxFacts=${effMaxFacts} effMaxQueryLimit=${effMaxQueryLimit} ` +
+          `gathered=${facts.length} (events=${facts.filter((f) => f.type === "event").length} ` +
+          `persons=${facts.filter((f) => f.type === "person").length} ` +
+          `items=${facts.filter((f) => f.type === "item").length}) ` +
+          `adapter=${(parsed.filters && parsed.filters.adapter) || "*"} ` +
+          `intent=${parsed.intent || "*"}\n`
+      );
+    } catch (_e) { /* stderr write failures are non-fatal */ }
 
     // Optional RAG augmentation.
     let ragContext = [];
@@ -135,10 +191,20 @@ class AnalysisEngine {
       systemPrompt: this.systemPrompt,
       intent: parsed.intent,
       timeWindow: parsed.timeWindow,
-      maxFacts: this.maxFacts,
+      maxFacts: effMaxFacts,
       vaultTotals: this._gatherVaultTotals(),
     });
 
+    // Telemetry: post-cap prompt size + truncation count. If `truncated` > 0
+    // the LLM is seeing fewer facts than _gatherFacts found.
+    try {
+      const promptChars = messages.reduce((s, m) => s + (m.content || "").length, 0);
+      process.stderr.write(
+        `[PDH-ASK] prompt factCount=${factCount} truncated=${truncated} ` +
+          `messages=${messages.length} promptChars=${promptChars}\n`
+      );
+    } catch (_e) { /* non-fatal */ }
+
     // Call LLM. **skipCache: true** is critical: PDH answers depend on
     // current vault state (new contacts / events / items ingested between
     // asks). The desktop LLMManager has a 7-day ResponseCache keyed on
@@ -224,6 +290,8 @@ class AnalysisEngine {
    * @param {object} [options]
    * @param {number} [options.now]
    * @param {boolean} [options.skipAudit=false]
+   * @param {number} [options.maxFacts]                per-call override (small-model budget)
+   * @param {number} [options.maxQueryLimit]           per-call override
    * @returns {Promise<RetrieveContextResult>}
    *
    * @typedef {object} RetrieveContextResult
@@ -232,7 +300,7 @@ class AnalysisEngine {
    * @property {Array<object>} facts
    * @property {string[]} factIds
    * @property {number} factCount
-   * @property {boolean} truncated
+   * @property {number} truncated   Count of facts dropped at the maxFacts cap (0 = nothing truncated)
    * @property {string[]} ragContextIds
    * @property {Array<{role: string, content: string}>} messages   prompt-builder output, LLM-ready
    * @property {string} systemPrompt
@@ -246,7 +314,17 @@ class AnalysisEngine {
 
     const startedAt = Date.now();
     const parsed = parseQuery(question, { now: options.now });
-    const facts = this._gatherFacts(parsed);
+
+    const effMaxFacts =
+      Number.isInteger(options.maxFacts) && options.maxFacts > 0
+        ? options.maxFacts
+        : this.maxFacts;
+    const effMaxQueryLimit =
+      Number.isInteger(options.maxQueryLimit) && options.maxQueryLimit > 0
+        ? options.maxQueryLimit
+        : this.maxQueryLimit;
+
+    const facts = this._gatherFacts(parsed, { maxFacts: effMaxFacts, maxQueryLimit: effMaxQueryLimit });
 
     const ragContextIds = [];
     if (this.ragRetriever) {
@@ -276,7 +354,7 @@ class AnalysisEngine {
       systemPrompt: this.systemPrompt,
       intent: parsed.intent,
       timeWindow: parsed.timeWindow,
-      maxFacts: this.maxFacts,
+      maxFacts: effMaxFacts,
       vaultTotals: this._gatherVaultTotals(),
     });
 
@@ -312,7 +390,91 @@ class AnalysisEngine {
 
   // ─── Internals ─────────────────────────────────────────────────────
 
-  _gatherFacts(parsed) {
+  _gatherFacts(parsed, budget = {}) {
+    // Per-call budget overrides constructor defaults — small-model callers
+    // (Android Qwen2.5-1.5B) pass tighter caps here.
+    const effMaxFacts =
+      Number.isInteger(budget.maxFacts) && budget.maxFacts > 0
+        ? budget.maxFacts
+        : this.maxFacts;
+    const effMaxQueryLimit =
+      Number.isInteger(budget.maxQueryLimit) && budget.maxQueryLimit > 0
+        ? budget.maxQueryLimit
+        : this.maxQueryLimit;
+
+    // Intent routing — intent=latest WITHOUT a time window means "newest
+    // few" (e.g. "最近的订单", "最新消息"). Hard-cap to
+    // LATEST_INTENT_FACT_LIMIT and skip persons/items entirely: the user
+    // is asking about an event timeline, not their contact list.
+    //
+    // When timeWindow IS set ("最近 30 天的消费" hits BOTH parseTimeWindow
+    // AND intent=latest), fall through to the default list-with-window
+    // path — a user asking for 30 days doesn't want 3 newest rows.
+    //
+    // Fallback: if the targeted query returns 0 events, fall through to
+    // the broader default behavior. Protects against low-confidence
+    // classifier picks (see pdh_analysis_engine_intent_routing memory).
+    if (parsed.intent === "latest" && !parsed.timeWindow) {
+      const latestQ = {
+        limit: Math.min(LATEST_INTENT_FACT_LIMIT, effMaxFacts),
+      };
+      if (parsed.filters && parsed.filters.adapter) {
+        latestQ.adapter = parsed.filters.adapter;
+      }
+      const latestEvents = this.vault.queryEvents(latestQ);
+      if (latestEvents.length > 0) return latestEvents;
+      // 0 results → fall through to default broader path below.
+    }
+
+    // intent=sum-amount routing — "总共花了多少" / "在淘宝花了多少钱"
+    // only needs events from amount-bearing subtypes (order/payment/
+    // transfer/income). Pulling messages / visits / browses wastes
+    // prompt budget on rows the LLM can't aggregate into a sum.
+    //
+    // We split the budget across the 4 subtypes (min 20 each, floor),
+    // union the results, dedup by id (an event would only appear once
+    // anyway since subtype is unique per event — defensive), and sort
+    // by occurredAt DESC. Adapter + time window are passed through so
+    // "上个月在淘宝总共花了多少" stays scoped.
+    //
+    // Skip persons/items — they don't carry amounts.
+    //
+    // 0 hits → return EMPTY (do NOT fall through). If the user asks
+    // "总共花了多少" and the vault has zero amount-bearing events under
+    // adapter+time scope, the default path would pull messages / visits /
+    // browsing rows the LLM might wrongly try to sum. Empty FACTS +
+    // warning="no-facts" + TOTALS preamble lets the model say "找不到
+    // 相关花费记录" cleanly. This diverges from latest's fallback (which
+    // surfaces persons/items for general "what's recent" context); for
+    // sum-amount that fallback would actively mislead.
+    if (parsed.intent === "sum-amount") {
+      const perSubtype = Math.max(
+        SUM_AMOUNT_MIN_PER_SUBTYPE,
+        Math.floor(effMaxQueryLimit / SUM_AMOUNT_SUBTYPES.length)
+      );
+      const seen = new Set();
+      const amountEvents = [];
+      for (const sub of SUM_AMOUNT_SUBTYPES) {
+        const subQ = { limit: perSubtype, subtype: sub };
+        if (parsed.filters && parsed.filters.adapter) {
+          subQ.adapter = parsed.filters.adapter;
+        }
+        if (parsed.timeWindow) {
+          if (Number.isFinite(parsed.timeWindow.since)) subQ.since = parsed.timeWindow.since;
+          if (Number.isFinite(parsed.timeWindow.until)) subQ.until = parsed.timeWindow.until;
+        }
+        const rows = this.vault.queryEvents(subQ);
+        for (const e of rows) {
+          if (e && e.id && !seen.has(e.id)) {
+            seen.add(e.id);
+            amountEvents.push(e);
+          }
+        }
+      }
+      amountEvents.sort((a, b) => (b.occurredAt || 0) - (a.occurredAt || 0));
+      return amountEvents.slice(0, effMaxFacts);
+    }
+
     // Deliberately do NOT pass parsed.filters.subtype as a vault filter:
     // the keyword heuristic (`order` vs `payment` vs `transfer`) is too
     // crude to reliably narrow without false negatives. E.g. a user
@@ -323,7 +485,7 @@ class AnalysisEngine {
     // apply on prose. The LLM is good at filtering; SQL keyword guessing
     // is brittle.
     const q = {
-      limit: this.maxQueryLimit,
+      limit: effMaxQueryLimit,
     };
     if (parsed.filters && parsed.filters.adapter) q.adapter = parsed.filters.adapter;
     if (parsed.timeWindow) {
@@ -332,6 +494,58 @@ class AnalysisEngine {
     }
     const events = this.vault.queryEvents(q);
 
+    // intent=list + entity-name FTS5 augmentation — when the question
+    // carries a probable entity-name candidate ("提到王老板的消息",
+    // "苹果的订单"), run an extra vault.searchEvents(q=term) and append
+    // hits not already in `events`. Adapter + time window are passed
+    // through so the FTS slice stays consistent with the main query.
+    //
+    // Strictly additive: the FTS hits are appended to `events` (no
+    // replacement). Wrong term extraction at worst returns 0 rows; FTS
+    // errors are swallowed — main path (events + persons + items) stays
+    // intact. See pdh_analysis_engine_intent_routing.md.
+    //
+    // Skipped for intent ∈ {count, sum-amount, latest}:
+    //   - count uses TOTALS preamble; FACTS sample doesn't need padding
+    //   - sum-amount is value-aggregation; entity-name hits don't help
+    //   - latest already returned earlier via narrow path
+    if (
+      parsed.intent === "list" &&
+      typeof this.vault.searchEvents === "function"
+    ) {
+      const entityTerm = extractEntityTerm(parsed.raw);
+      if (entityTerm) {
+        const headroom = effMaxFacts - events.length;
+        if (headroom > 0) {
+          try {
+            const ftsQ = {
+              q: entityTerm,
+              limit: Math.min(headroom, LIST_INTENT_FTS_LIMIT),
+            };
+            if (parsed.filters && parsed.filters.adapter) {
+              ftsQ.adapter = parsed.filters.adapter;
+            }
+            if (parsed.timeWindow) {
+              if (Number.isFinite(parsed.timeWindow.since)) ftsQ.since = parsed.timeWindow.since;
+              if (Number.isFinite(parsed.timeWindow.until)) ftsQ.until = parsed.timeWindow.until;
+            }
+            const ftsResult = this.vault.searchEvents(ftsQ);
+            if (ftsResult && Array.isArray(ftsResult.rows)) {
+              const existingIds = new Set(events.map((e) => e.id));
+              for (const row of ftsResult.rows) {
+                if (row && row.id && !existingIds.has(row.id)) {
+                  events.push(row);
+                  existingIds.add(row.id);
+                }
+              }
+            }
+          } catch (_e) {
+            // FTS failure is non-fatal — main events array already populated.
+          }
+        }
+      }
+    }
+
     // Path C follow-up — events alone miss whole categories of facts:
     //  - contacts (system-data-android) land in `persons`, not `events`
     //  - installed apps land in `items`, not `events`
@@ -349,7 +563,7 @@ class AnalysisEngine {
     // state snapshots that should always be visible. Adapter filter is also
     // skipped because users asking "我有几个联系人" don't say "from
     // system-data-android".
-    const remaining = Math.max(0, this.maxFacts - events.length);
+    const remaining = Math.max(0, effMaxFacts - events.length);
     const sideBudget = Math.floor(remaining / 2);
     const personBudget = sideBudget > 0 ? sideBudget : 0;
     const itemBudget = remaining - personBudget;
@@ -412,4 +626,8 @@ module.exports = {
   AnalysisEngine,
   DEFAULT_MAX_FACTS,
   DEFAULT_MAX_QUERY_LIMIT,
+  LATEST_INTENT_FACT_LIMIT,
+  LIST_INTENT_FTS_LIMIT,
+  SUM_AMOUNT_SUBTYPES,
+  SUM_AMOUNT_MIN_PER_SUBTYPE,
 };

package/lib/categories.js

@@ -0,0 +1,101 @@
+/**
+ * Shared adapter → category taxonomy for the PDH Vault Browser UI.
+ *
+ * Single source of truth consumed by:
+ *   - packages/web-panel (desktop browser view)
+ *   - packages/cli (cc hub search --category)
+ *   - android-app (mirrored as Kotlin enum in PdhCategoryMap.kt; keep in sync)
+ *
+ * Categories are stable user-facing buckets (社交聊天 / 内容平台 / ...) — the
+ * browser sidebar keys off these, not raw adapter names. New adapters get
+ * mapped here once and surface in the right bucket on both shells.
+ *
+ * Matching is prefix-based by adapter name so we don't have to touch this
+ * file for every adapter variant (e.g. `email-imap-qq`, `email-imap-gmail`).
+ * First matching prefix wins; order in PREFIX_RULES matters for overlapping
+ * prefixes (none today, but reserve the right).
+ */
+
+"use strict";
+
+const CATEGORIES = Object.freeze([
+  "chat",      // 即时通讯 / 私聊
+  "social",    // 内容平台 / 短视频 / 微博
+  "email",     // 邮件
+  "shopping",  // 支付 / 订单 / 购物
+  "travel",    // 出行 / 地图 / 票务
+  "system",    // 系统数据（通讯录 / 应用列表）
+  "ai-chat",   // AI 助手对话历史
+  "other",     // 兜底
+]);
+
+const CATEGORY_LABELS = Object.freeze({
+  chat:      "社交聊天",
+  social:    "内容平台",
+  email:     "邮件",
+  shopping:  "支付订单",
+  travel:    "出行",
+  system:    "系统数据",
+  "ai-chat": "AI 对话",
+  other:     "其他",
+});
+
+// Ordered prefix → category rules. First match wins.
+// Each entry: [prefixOrExact, category].
+// Use a trailing `*` to mean "prefix match"; absent `*` means exact match.
+const PREFIX_RULES = Object.freeze([
+  ["wechat",          "chat"],
+  ["messaging-*",     "chat"],
+  ["social-*",        "social"],
+  ["email-*",         "email"],
+  ["shopping-*",      "shopping"],
+  ["alipay-*",        "shopping"],
+  ["travel-*",        "travel"],
+  ["system-data*",    "system"],
+  ["browser-*",       "system"],
+  ["vscode",          "system"],
+  ["win-recent",      "system"],
+  ["git-activity",    "system"],
+  ["shell-history",   "system"],
+  ["local-files",     "system"],
+  ["ai-chat-*",       "ai-chat"],
+]);
+
+/**
+ * Map an adapter name to its category.
+ * @param {string} adapterName  e.g. "social-bilibili" / "email-imap-qq" / "wechat"
+ * @returns {string} category id from CATEGORIES (never throws — falls back to "other")
+ */
+function getCategory(adapterName) {
+  if (typeof adapterName !== "string" || adapterName.length === 0) return "other";
+  for (const [rule, cat] of PREFIX_RULES) {
+    if (rule.endsWith("*")) {
+      const prefix = rule.slice(0, -1);
+      if (adapterName.startsWith(prefix)) return cat;
+    } else if (adapterName === rule) {
+      return cat;
+    }
+  }
+  return "other";
+}
+
+/**
+ * Group a list of adapter names by category. Returns
+ * `{ [category]: string[] }` with empty categories omitted.
+ */
+function groupByCategory(adapterNames) {
+  const out = {};
+  for (const name of adapterNames || []) {
+    const c = getCategory(name);
+    (out[c] ||= []).push(name);
+  }
+  return out;
+}
+
+module.exports = {
+  CATEGORIES,
+  CATEGORY_LABELS,
+  PREFIX_RULES,
+  getCategory,
+  groupByCategory,
+};

package/lib/index.js

@@ -58,6 +58,14 @@ const entityResolver = require("./entity-resolver");
 const analysisSkills = require("./analysis-skills");
 const mobileExtractor = require("./mobile-extractor");
 const systemDataAndroid = require("./adapters/system-data-android");
+const browserHistoryChrome = require("./adapters/browser-history-chrome");
+const browserHistoryEdge = require("./adapters/browser-history-edge");
+const vscodeAdapter = require("./adapters/vscode");
+const winRecentAdapter = require("./adapters/win-recent");
+const gitActivityAdapter = require("./adapters/git-activity");
+const shellHistoryAdapter = require("./adapters/shell-history");
+const localFilesAdapter = require("./adapters/local-files");
+const categories = require("./categories");
 
 module.exports = {
   // Constants / enums
@@ -87,6 +95,7 @@ module.exports = {
   TARGET_SCHEMA_VERSION: migrations.TARGET_VERSION,
   applyMigrations: migrations.applyMigrations,
   getSchemaVersion: migrations.getSchemaVersion,
+  getFtsMode: migrations.getFtsMode,
 
   // Key providers
   KEY_HEX_LEN: keyProviders.KEY_HEX_LEN,
@@ -262,6 +271,51 @@ module.exports = {
   ingestSystemDataAndroidSnapshot:
     systemDataAndroid.ingestSystemDataAndroidSnapshot,
 
+  // Phase 17 (2026-05-24) — desktop Chrome local browser history + bookmarks.
+  // SQLite snapshot copy + Bookmarks JSON parse; no network, no extension.
+  BrowserHistoryChromeAdapter: browserHistoryChrome.BrowserHistoryChromeAdapter,
+  BROWSER_HISTORY_CHROME_NAME: browserHistoryChrome.BROWSER_HISTORY_CHROME_NAME,
+  BROWSER_HISTORY_CHROME_VERSION: browserHistoryChrome.BROWSER_HISTORY_CHROME_VERSION,
+  defaultChromeProfileDir: browserHistoryChrome.defaultChromeProfileDir,
+
+  // Edge — Chromium under the hood, same readers, different profile root.
+  BrowserHistoryEdgeAdapter: browserHistoryEdge.BrowserHistoryEdgeAdapter,
+  BROWSER_HISTORY_EDGE_NAME: browserHistoryEdge.BROWSER_HISTORY_EDGE_NAME,
+  BROWSER_HISTORY_EDGE_VERSION: browserHistoryEdge.BROWSER_HISTORY_EDGE_VERSION,
+
+  // VS Code — workspace history + global terminal command/dir history.
+  VSCodeAdapter: vscodeAdapter.VSCodeAdapter,
+  VSCODE_NAME: vscodeAdapter.VSCODE_NAME,
+  VSCODE_VERSION: vscodeAdapter.VSCODE_VERSION,
+  defaultVscodeRoot: vscodeAdapter.defaultVscodeRoot,
+
+  // Windows Recent — .lnk shortcut list from %APPDATA%\Microsoft\Windows\Recent.
+  // Cross-application "what did I open and when" timeline (Win-only adapter).
+  WinRecentAdapter: winRecentAdapter.WinRecentAdapter,
+  WIN_RECENT_NAME: winRecentAdapter.WIN_RECENT_NAME,
+  WIN_RECENT_VERSION: winRecentAdapter.WIN_RECENT_VERSION,
+  defaultWinRecentDir: winRecentAdapter.defaultRecentDir,
+
+  // Phase 18 — git activity (commit timeline across local code repos).
+  GitActivityAdapter: gitActivityAdapter.GitActivityAdapter,
+  GIT_ACTIVITY_NAME: gitActivityAdapter.GIT_ACTIVITY_NAME,
+  GIT_ACTIVITY_VERSION: gitActivityAdapter.GIT_ACTIVITY_VERSION,
+  defaultCodeRoots: gitActivityAdapter.defaultCodeRoots,
+
+  // Phase 18 — shell history (PowerShell / bash / zsh command timelines).
+  ShellHistoryAdapter: shellHistoryAdapter.ShellHistoryAdapter,
+  SHELL_HISTORY_NAME: shellHistoryAdapter.SHELL_HISTORY_NAME,
+  SHELL_HISTORY_VERSION: shellHistoryAdapter.SHELL_HISTORY_VERSION,
+  defaultShellHistorySources: shellHistoryAdapter.defaultHistorySources,
+
+  // Phase 18 — local files (file walk under Documents / Desktop / Downloads /
+  // Pictures / Videos / Music). Cross-application "what files do I have"
+  // timeline rooted in mtime, with app-cache excludes baked in.
+  LocalFilesAdapter: localFilesAdapter.LocalFilesAdapter,
+  LOCAL_FILES_NAME: localFilesAdapter.LOCAL_FILES_NAME,
+  LOCAL_FILES_VERSION: localFilesAdapter.LOCAL_FILES_VERSION,
+  defaultLocalFileRoots: localFilesAdapter.defaultRoots,
+
   // Phase 6 — AlipayBillAdapter (CSV import)
   AlipayBillAdapter: alipayBillAdapter.AlipayBillAdapter,
   ALIPAY_BILL_NAME: alipayBillAdapter.ALIPAY_BILL_NAME,
@@ -273,4 +327,11 @@ module.exports = {
   alipayCounterpartyToPersonId: alipayBillAdapter.alipayCounterpartyToPersonId,
   ALIPAY_KNOWN_MERCHANTS: alipayBillAdapter.ALIPAY_KNOWN_MERCHANTS,
   mapAlipayTypeToSubtype: alipayBillAdapter.mapAlipayTypeToSubtype,
+
+  // Phase 16 — Vault Browser shared taxonomy (categories + adapter mapping)
+  CATEGORIES: categories.CATEGORIES,
+  CATEGORY_LABELS: categories.CATEGORY_LABELS,
+  PDH_PREFIX_RULES: categories.PREFIX_RULES,
+  getAdapterCategory: categories.getCategory,
+  groupAdaptersByCategory: categories.groupByCategory,
 };