@chainlesschain/personal-data-hub 0.1.0 → 0.2.1

package/__tests__/analysis.test.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { describe, it, expect, afterEach } from "vitest";
+import { describe, it, expect, afterEach, vi } from "vitest";
 
 const fs = require("node:fs");
 const os = require("node:os");
@@ -287,6 +287,241 @@ describe("AnalysisEngine RAG retriever", () => {
   });
 });
 
+// ─── TOTALS block — authoritative counts beat FACTS sample length ─────
+//
+// Bug 2026-05-21: even after _gatherFacts pulled persons + items into the
+// prompt, the LLM still said "32 contacts" because FACTS is capped at 80
+// items and the LLM was counting the array. Real vault had ~500 contacts.
+// Fix: stick vault.stats() totals at the head of the user message so the
+// model has an authoritative ground-truth number to quote.
+
+describe("AnalysisEngine emits TOTALS preamble", () => {
+  it("includes vault.stats() totals in the prompt", async () => {
+    const fakeVault = {
+      queryEvents: () => [],
+      queryPersons: () => [],
+      queryItems: () => [],
+      stats: () => ({ events: 12, persons: 512, places: 3, items: 89, topics: 0 }),
+      getEvent: () => null,
+      audit: () => {},
+    };
+    const chatCalls = [];
+    const llm = {
+      isLocal: true,
+      chat: async (msgs) => {
+        chatCalls.push(msgs);
+        return { text: "ok", usage: {} };
+      },
+    };
+    const engine = new AnalysisEngine({ vault: fakeVault, llm });
+    await engine.ask("几个联系人");
+    const userMsg = chatCalls[0][1].content;
+    expect(userMsg).toContain("TOTALS");
+    expect(userMsg).toContain('"persons": 512');
+    expect(userMsg).toContain('"items": 89');
+    // System prompt tells LLM to trust TOTALS for counts.
+    expect(chatCalls[0][0].content).toMatch(/TOTALS.*authoritative/);
+  });
+
+  it("intent=count for '几个联系人' and '几个 app' and '多少个 X'", () => {
+    const { parseQuery } = require("../lib/query-parser");
+    expect(parseQuery("几个联系人").intent).toBe("count");
+    expect(parseQuery("几个 app").intent).toBe("count");
+    expect(parseQuery("我有多少个联系人？").intent).toBe("count");
+    expect(parseQuery("how many contacts do I have").intent).toBe("count");
+    expect(parseQuery("列出我的联系人").intent).toBe("list");
+  });
+
+  it("legacy vault without stats() falls back gracefully — no TOTALS block", async () => {
+    const legacyVault = {
+      queryEvents: () => [],
+      // no stats()
+      getEvent: () => null,
+      audit: () => {},
+    };
+    const chatCalls = [];
+    const llm = {
+      isLocal: true,
+      chat: async (msgs) => {
+        chatCalls.push(msgs);
+        return { text: "ok", usage: {} };
+      },
+    };
+    const engine = new AnalysisEngine({ vault: legacyVault, llm });
+    await engine.ask("test");
+    const userMsg = chatCalls[0][1].content;
+    expect(userMsg).not.toContain("TOTALS");
+  });
+});
+
+// ─── Cache bypass — PDH ask must always go to LLM, never cached ───────
+//
+// Bug 2026-05-21: desktop ResponseCache (7-day TTL) served a stale
+// hallucinated answer ("32 contacts") even after _gatherFacts fix put real
+// persons in the prompt — same sha256(messages) hit from an earlier session.
+// AnalysisEngine.ask must pass skipCache:true so LLMManager bypasses cache.
+
+describe("AnalysisEngine.ask cache bypass", () => {
+  it("passes skipCache:true to llm.chat options", async () => {
+    freshVault();
+    seedOrders(vault);
+    const chatCalls = [];
+    const llm = {
+      isLocal: true,
+      chat: async (messages, opts) => {
+        chatCalls.push({ messages, opts });
+        return { text: "ok", usage: {} };
+      },
+    };
+    const engine = new AnalysisEngine({ vault, llm });
+    await engine.ask("test", { now: NOW });
+    expect(chatCalls).toHaveLength(1);
+    expect(chatCalls[0].opts.skipCache).toBe(true);
+  });
+
+  it("retrieveContext does NOT need skipCache (no LLM call)", async () => {
+    freshVault();
+    seedOrders(vault);
+    const llm = {
+      isLocal: true,
+      chat: () => {
+        throw new Error("must not be called");
+      },
+    };
+    const engine = new AnalysisEngine({ vault, llm });
+    // retrieveContext is Path Y — caller hosts the LLM, so cache concerns
+    // belong to the caller, not us. Don't pass skipCache here.
+    const r = await engine.retrieveContext("test");
+    expect(r.factCount).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ─── Path C follow-up — persons / items show up as facts ───────────────
+//
+// Bug 2026-05-21: "我有几个联系人" hallucinated "2" because contacts ingest
+// into persons table but _gatherFacts only queried events. Fix: pull persons
+// + items into facts within the maxFacts budget.
+
+describe("AnalysisEngine._gatherFacts includes persons and items", () => {
+  it("returns persons + items even when events are empty (contacts-only vault)", async () => {
+    freshVault();
+    // Use a fake vault that exposes queryPersons / queryItems but no event
+    // history — mimics the post-Path-C-ingest state where contacts +
+    // installed apps are the only data.
+    const fakeVault = {
+      queryEvents: () => [],
+      queryPersons: ({ limit }) => {
+        const n = Math.min(limit ?? 100, 5);
+        return Array.from({ length: n }, (_, i) => ({
+          id: "person-android-" + i,
+          type: "person",
+          subtype: "contact",
+          names: ["联系人" + i],
+          ingestedAt: Date.now(),
+          source: {
+            adapter: "system-data-android",
+            adapterVersion: "0.1.0",
+            capturedAt: Date.now(),
+            capturedBy: "api",
+          },
+        }));
+      },
+      queryItems: ({ limit }) => {
+        const n = Math.min(limit ?? 100, 3);
+        return Array.from({ length: n }, (_, i) => ({
+          id: "item-android-app-com.foo" + i,
+          type: "item",
+          subtype: "other",
+          name: "App" + i,
+          ingestedAt: Date.now(),
+          source: {
+            adapter: "system-data-android",
+            adapterVersion: "0.1.0",
+            capturedAt: Date.now(),
+            capturedBy: "api",
+          },
+        }));
+      },
+      getEvent: () => null,
+      audit: () => {},
+    };
+    const llm = new MockLLMClient({ reply: "你共有 5 个联系人" });
+    const engine = new AnalysisEngine({ vault: fakeVault, llm });
+    const r = await engine.ask("我有几个联系人");
+    expect(r.facts.length).toBe(8); // 0 events + 5 persons + 3 items
+    expect(r.facts.filter((f) => f.type === "person").length).toBe(5);
+    expect(r.facts.filter((f) => f.type === "item").length).toBe(3);
+  });
+
+  it("respects maxFacts budget — events get majority, persons + items split remainder", async () => {
+    const fakeVault = {
+      queryEvents: () => Array.from({ length: 60 }, (_, i) => ({
+        id: "event-" + i, type: "event", subtype: "order",
+        occurredAt: Date.now(), actor: "person-self",
+        ingestedAt: Date.now(), source: {
+          adapter: "taobao", adapterVersion: "0", capturedAt: Date.now(), capturedBy: "api",
+        },
+      })),
+      queryPersons: ({ limit }) => Array.from({ length: Math.min(limit, 100) }, (_, i) => ({
+        id: "p-" + i, type: "person", subtype: "contact",
+        names: ["P" + i], ingestedAt: Date.now(),
+        source: { adapter: "system-data-android", adapterVersion: "0", capturedAt: Date.now(), capturedBy: "api" },
+      })),
+      queryItems: ({ limit }) => Array.from({ length: Math.min(limit, 100) }, (_, i) => ({
+        id: "i-" + i, type: "item", subtype: "other", name: "Item" + i,
+        ingestedAt: Date.now(),
+        source: { adapter: "system-data-android", adapterVersion: "0", capturedAt: Date.now(), capturedBy: "api" },
+      })),
+      getEvent: () => null,
+      audit: () => {},
+    };
+    const llm = new MockLLMClient({ reply: "" });
+    const engine = new AnalysisEngine({ vault: fakeVault, llm, maxFacts: 80 });
+    const r = await engine.retrieveContext("hello");
+    // 60 events + budget for the rest. remaining = 80-60 = 20 → 10 persons + 10 items
+    expect(r.facts.filter((f) => f.type === "event").length).toBe(60);
+    expect(r.facts.filter((f) => f.type === "person").length).toBe(10);
+    expect(r.facts.filter((f) => f.type === "item").length).toBe(10);
+  });
+
+  it("gracefully degrades when vault lacks queryPersons / queryItems (legacy fork)", async () => {
+    const legacyVault = {
+      queryEvents: () => [],
+      // no queryPersons / queryItems methods
+      getEvent: () => null,
+      audit: () => {},
+    };
+    const llm = new MockLLMClient({ reply: "" });
+    const engine = new AnalysisEngine({ vault: legacyVault, llm });
+    const r = await engine.ask("hello");
+    expect(r.facts.length).toBe(0);
+    expect(r.warning).toBe("no-facts");
+  });
+
+  it("events take majority when budget < events.length (no person/item budget left)", async () => {
+    const fakeVault = {
+      queryEvents: () => Array.from({ length: 80 }, (_, i) => ({
+        id: "e" + i, type: "event", subtype: "order",
+        occurredAt: Date.now(), actor: "self",
+        ingestedAt: Date.now(),
+        source: { adapter: "taobao", adapterVersion: "0", capturedAt: Date.now(), capturedBy: "api" },
+      })),
+      queryPersons: vi.fn(() => []),
+      queryItems: vi.fn(() => []),
+      getEvent: () => null,
+      audit: () => {},
+    };
+    const llm = new MockLLMClient({ reply: "" });
+    const engine = new AnalysisEngine({ vault: fakeVault, llm, maxFacts: 80 });
+    const r = await engine.ask("hi");
+    expect(r.facts.length).toBe(80);
+    // budget exhausted → queryPersons / queryItems still called but with limit 0
+    // (current impl skips with personBudget <= 0). Verify they're NOT called.
+    expect(fakeVault.queryPersons).not.toHaveBeenCalled();
+    expect(fakeVault.queryItems).not.toHaveBeenCalled();
+  });
+});
+
 // ─── Empty / bad input ────────────────────────────────────────────────────
 
 describe("AnalysisEngine input validation", () => {
@@ -300,3 +535,96 @@ describe("AnalysisEngine input validation", () => {
     await expect(engine.ask(null)).rejects.toThrow();
   });
 });
+
+// ─── retrieveContext: prompt assembly without LLM call ───────────────────
+//
+// Path Y wiring lets a mobile front-end host the LLM call locally (e.g. the
+// Android-side Volcengine Doubao adapter) while keeping vault + retrieval on
+// the desktop. retrieveContext mirrors the front half of ask() and returns
+// the assembled messages so the caller can hand them straight to its own LLM.
+
+describe("AnalysisEngine.retrieveContext", () => {
+  it("returns parsed + facts + messages without invoking the LLM", async () => {
+    freshVault();
+    const [e1, e2, e3] = seedOrders(vault);
+
+    // LLM that would throw if called — proves retrieveContext is LLM-free.
+    const llm = {
+      isLocal: true,
+      chat: () => { throw new Error("LLM must not be called by retrieveContext"); },
+    };
+    const engine = new AnalysisEngine({ vault, llm });
+    const r = await engine.retrieveContext("上个月在淘宝总共花了多少？", { now: NOW });
+
+    expect(r.question).toBe("上个月在淘宝总共花了多少？");
+    expect(r.parsed.filters.adapter).toBe("taobao");
+    expect(r.facts.length).toBe(3);
+    expect(r.factIds).toEqual(expect.arrayContaining([e1.id, e2.id, e3.id]));
+    expect(r.factCount).toBe(3);
+    expect(r.truncated).toBe(false);
+    expect(Array.isArray(r.messages)).toBe(true);
+    expect(r.messages.length).toBeGreaterThan(0);
+    expect(r.messages[0]).toHaveProperty("role");
+    expect(r.messages[0]).toHaveProperty("content");
+    expect(r.systemPrompt).toBeTypeOf("string");
+    expect(r.retrievedAt).toBeTypeOf("number");
+    expect(r.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it("ignores acceptNonLocal — privacy gate does not apply (no LLM contacted)", async () => {
+    freshVault();
+    seedOrders(vault);
+    // Non-local LLM declared on the engine, but retrieveContext doesn't call it.
+    const llm = {
+      isLocal: false,
+      chat: () => { throw new Error("must not be called"); },
+    };
+    const engine = new AnalysisEngine({ vault, llm });
+    // No acceptNonLocal option needed.
+    const r = await engine.retrieveContext("test", { now: NOW });
+    expect(r.factCount).toBeGreaterThanOrEqual(0);
+  });
+
+  it("incorporates RAG retriever results into facts", async () => {
+    freshVault();
+    const orders = seedOrders(vault);
+    const ragRetriever = async () => [{ id: orders[3].id, text: "fake", metadata: {} }];
+    const llm = { isLocal: true, chat: () => { throw new Error("nope"); } };
+    const engine = new AnalysisEngine({ vault, llm, ragRetriever });
+    const r = await engine.retrieveContext("上个月在淘宝总共花了多少？", { now: NOW });
+    expect(r.facts.length).toBe(4);
+    expect(r.ragContextIds).toEqual([orders[3].id]);
+  });
+
+  it("RAG failure is captured but doesn't abort retrieval", async () => {
+    freshVault();
+    seedOrders(vault);
+    const ragRetriever = async () => { throw new Error("qdrant unreachable"); };
+    const llm = { isLocal: true, chat: () => { throw new Error("nope"); } };
+    const engine = new AnalysisEngine({ vault, llm, ragRetriever });
+    const r = await engine.retrieveContext("test", { now: NOW });
+    expect(r.factCount).toBeGreaterThanOrEqual(0);
+    const audits = vault.queryAudit({ action: "analysis.rag_failed" });
+    expect(audits.length).toBe(1);
+  });
+
+  it("writes analysis.retrieve_context audit row by default", async () => {
+    freshVault();
+    seedOrders(vault);
+    const llm = { isLocal: true, chat: () => { throw new Error("nope"); } };
+    const engine = new AnalysisEngine({ vault, llm });
+    await engine.retrieveContext("test", { now: NOW });
+    const audits = vault.queryAudit({ action: "analysis.retrieve_context" });
+    expect(audits.length).toBe(1);
+  });
+
+  it("rejects empty / non-string question", async () => {
+    freshVault();
+    const engine = new AnalysisEngine({
+      vault,
+      llm: new MockLLMClient({ reply: "" }),
+    });
+    await expect(engine.retrieveContext("")).rejects.toThrow(/non-empty/);
+    await expect(engine.retrieveContext(null)).rejects.toThrow();
+  });
+});

package/__tests__/e2e/ai-chat-cross-source-journey.test.js

@@ -0,0 +1,213 @@
+"use strict";
+
+// E2E — Personal Data Hub cross-source journey including Phase 10.2 AIChat.
+//
+// User has:
+//   1. Two AI vendors with chat history (DeepSeek + Kimi)
+//   2. EntityResolver wires up vendor Persons as ai-agents
+//   3. Timeline + Relations skills weave AI conversations into the same
+//      chronological story as other data sources (RAG-ready surface).
+//
+// Verifies the Phase 10.2 wiring through the entire stack — sync → vault
+// → KG/RAG sinks → analysis skills — using fixture HTTP (no live cookies).
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+const {
+  LocalVault, generateKeyHex, AdapterRegistry,
+  EntityResolver,
+  TimelineSkill, RelationsSkill,
+} = require("../../lib");
+const {
+  AIChatHistoryAdapter, CookieAuthSession,
+} = require("../../lib/adapters/ai-chat-history");
+
+function makeResponse({ status = 200, body = {} } = {}) {
+  return {
+    status,
+    ok: status >= 200 && status < 300,
+    headers: { get: () => null },
+    async json() { return body; },
+  };
+}
+
+function makeRoutedFetch(routes) {
+  return async (url, init) => {
+    for (const [pattern, response] of routes) {
+      if (typeof pattern === "string" ? url.includes(pattern) : pattern.test(url)) {
+        if (typeof response === "function") return response(url, init);
+        return response;
+      }
+    }
+    return makeResponse({ status: 404 });
+  };
+}
+
+function makeClock() {
+  let t = 1700000000_000;
+  return { now: () => t, sleep: async (ms) => { t += ms; } };
+}
+
+describe("E2E — Personal Data Hub cross-source journey with AIChat", () => {
+  let dir, vault, registry, resolver;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "pdh-aichat-e2e-"));
+    vault = new LocalVault({ path: path.join(dir, "v.db"), key: generateKeyHex() });
+    vault.open();
+    resolver = new EntityResolver({ vault });
+    registry = new AdapterRegistry({ vault, entityResolver: resolver });
+  });
+
+  afterEach(() => {
+    try { vault.close(); } catch (_e) {}
+    try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_e) {}
+  });
+
+  it("two AIChat vendors land in vault; TimelineSkill returns interleaved events", async () => {
+    const clk = makeClock();
+    const fetch = makeRoutedFetch([
+      // DeepSeek
+      ["/get_user_info", makeResponse({ body: { code: 0, data: { biz_data: { user_id: "ds-u1" } } } })],
+      [/fetch_page.*before=/, makeResponse({ body: { data: { biz_data: { chat_sessions: [] } } } })],
+      ["/chat_session/fetch_page", makeResponse({ body: { data: { biz_data: { chat_sessions: [
+        { id: "ds-c1", title: "DeepSeek code review", model: "deepseek-r1", inserted_at: 1700000100, updated_at: 1700000200 },
+      ] } } } })],
+      ["/chat/history_messages", makeResponse({ body: { data: { biz_data: { chat_messages: [
+        { id: "ds-m1", role: "USER", content: "explain this Go race condition", inserted_at: 1700000100 },
+        { id: "ds-m2", role: "ASSISTANT", content: "The issue is the unlocked mutex...", inserted_at: 1700000150, model: "deepseek-r1" },
+      ] } } } })],
+      // Kimi
+      ["/api/user", makeResponse({ body: { id: "km-u1" } })],
+      [/list\?offset=30/, makeResponse({ body: { items: [], total: 1 } })],
+      [/list\?offset=0/, makeResponse({ body: { items: [
+        { id: "km-c1", name: "Kimi 200k context Q", created_at: 1700000300, updated_at: 1700000400 },
+      ], total: 1 } })],
+      [/segment\/scroll/, async (_url, init) => {
+        const body = JSON.parse(init.body);
+        if (body.last === "0") {
+          return makeResponse({ body: {
+            items: [
+              { id: "km-msg-1", role: "user", content: "summarize this paper", created_at: 1700000300 },
+              { id: "km-msg-2", role: "assistant", content: "The paper proposes...", created_at: 1700000350 },
+            ],
+            has_more: false,
+          } });
+        }
+        return makeResponse({ body: { items: [], has_more: false } });
+      }],
+    ]);
+
+    const adapter = new AIChatHistoryAdapter({ fetch, sleep: clk.sleep, now: clk.now });
+    adapter.setSession("deepseek", new CookieAuthSession({
+      vendor: "deepseek",
+      cookies: [{ name: "userToken", value: "ds-cookie" }],
+    }));
+    adapter.setSession("kimi", new CookieAuthSession({
+      vendor: "kimi",
+      cookies: [{ name: "access_token", value: "km-cookie" }],
+    }));
+    registry.register(adapter);
+
+    // ─── Sync ──────────────────────────────────────────────
+    const report = await registry.syncAdapter("ai-chat-history");
+    expect(report.status).toBe("ok");
+    expect(report.invalidCount).toBe(0);
+    expect(report.rawCount).toBeGreaterThanOrEqual(6); // 2 convs + 4 msgs
+
+    // ─── Vault inspection ──────────────────────────────────
+    const events = vault.queryEvents({ adapter: "ai-chat-history", limit: 100 });
+    expect(events.length).toBe(4); // 2 deepseek msgs + 2 kimi msgs
+
+    // Both vendors present
+    const vendors = new Set(events.map((e) => e.extra && e.extra.vendor).filter(Boolean));
+    expect(vendors.has("deepseek")).toBe(true);
+    expect(vendors.has("kimi")).toBe(true);
+
+    // Vendor AI-agent Persons deduped
+    const aiAgentCount = vault.db
+      .prepare("SELECT COUNT(*) AS n FROM persons WHERE subtype = 'ai-agent'")
+      .get().n;
+    expect(aiAgentCount).toBe(2);
+
+    // ─── TimelineSkill: events interleaved by time ─────────
+    const timeline = new TimelineSkill({ vault });
+    const result = await timeline.run({ since: 1700000000_000, until: 1700001000_000, limit: 100 });
+    expect(result.entries.length).toBeGreaterThanOrEqual(4);
+
+    // Both vendors appear via the timeline entries (each entry references an event)
+    const allText = result.entries.map((e) => JSON.stringify(e)).join(" ");
+    expect(allText).toMatch(/Go race|race condition/);
+    expect(allText).toMatch(/summarize this paper|paper proposes/);
+  });
+
+  it("RelationsSkill aggregates AI-agent interactions across vendors", async () => {
+    const clk = makeClock();
+    const fetch = makeRoutedFetch([
+      ["/get_user_info", makeResponse({ body: { code: 0, data: { biz_data: { user_id: "ds-u1" } } } })],
+      [/fetch_page.*before=/, makeResponse({ body: { data: { biz_data: { chat_sessions: [] } } } })],
+      ["/chat_session/fetch_page", makeResponse({ body: { data: { biz_data: { chat_sessions: [
+        { id: "ds-c1", title: "ds chat", model: "deepseek-r1", inserted_at: 1700000100, updated_at: 1700000200 },
+      ] } } } })],
+      ["/chat/history_messages", makeResponse({ body: { data: { biz_data: { chat_messages: [
+        { id: "ds-m1", role: "USER", content: "hi", inserted_at: 1700000100 },
+        { id: "ds-m2", role: "ASSISTANT", content: "hi back", inserted_at: 1700000110 },
+        { id: "ds-m3", role: "USER", content: "more questions", inserted_at: 1700000120 },
+      ] } } } })],
+    ]);
+
+    const adapter = new AIChatHistoryAdapter({ fetch, sleep: clk.sleep, now: clk.now });
+    adapter.setSession("deepseek", new CookieAuthSession({ vendor: "deepseek", cookies: [] }));
+    registry.register(adapter);
+
+    await registry.syncAdapter("ai-chat-history");
+
+    const skill = new RelationsSkill({ vault });
+    const r = await skill.run({ personId: "person-ai-deepseek" });
+    expect(r.profile.totalInteractions).toBeGreaterThan(0);
+  });
+
+  it("AIChat + cookie-expired sentinel: partial success, journey continues", async () => {
+    const clk = makeClock();
+    // DeepSeek returns 401 (expired); Kimi works.
+    const fetch = makeRoutedFetch([
+      [/chat_session\/fetch_page/, makeResponse({ status: 401 })],
+      ["/api/user", makeResponse({ body: { id: "km-u1" } })],
+      [/list\?offset=30/, makeResponse({ body: { items: [], total: 1 } })],
+      [/list\?offset=0/, makeResponse({ body: { items: [
+        { id: "km-c1", name: "still works", created_at: 1700000300, updated_at: 1700000400 },
+      ], total: 1 } })],
+      [/segment\/scroll/, async (_url, init) => {
+        const body = JSON.parse(init.body);
+        if (body.last === "0") {
+          return makeResponse({ body: {
+            items: [{ id: "km-msg-1", role: "user", content: "hi kimi", created_at: 1700000300 }],
+            has_more: false,
+          } });
+        }
+        return makeResponse({ body: { items: [], has_more: false } });
+      }],
+    ]);
+    const adapter = new AIChatHistoryAdapter({ fetch, sleep: clk.sleep, now: clk.now });
+    adapter.setSession("deepseek", new CookieAuthSession({ vendor: "deepseek", cookies: [] }));
+    adapter.setSession("kimi", new CookieAuthSession({ vendor: "kimi", cookies: [] }));
+    registry.register(adapter);
+
+    const report = await registry.syncAdapter("ai-chat-history");
+    expect(report.status).toBe("ok");
+
+    // Kimi events landed even though DeepSeek failed.
+    const allEvents = vault.queryEvents({ adapter: "ai-chat-history", limit: 100 });
+    const kimiEvents = allEvents.filter((e) => e.extra && e.extra.vendor === "kimi");
+    expect(kimiEvents.length).toBeGreaterThan(0);
+
+    // Timeline still returns kimi event despite deepseek failure.
+    const timeline = new TimelineSkill({ vault });
+    const result = await timeline.run({ since: 1700000000_000, until: 1700001000_000, limit: 100 });
+    expect(result.entries.length).toBeGreaterThan(0);
+  });
+});