@chainlesschain/personal-data-hub 0.2.3 → 0.3.0

package/__tests__/adapters/system-data-android.test.js

@@ -48,7 +48,9 @@ describe("SystemDataAndroidAdapter — contract", () => {
     expect(adapter.name).toBe(SYSTEM_DATA_ANDROID_NAME);
     expect(adapter.version).toBe(SYSTEM_DATA_ANDROID_VERSION);
     expect(adapter.extractMode).toBe("device-pull");
-    expect(adapter.dataDisclosure.sensitivity).toBe("medium");
+    // v0.2 bumped sensitivity medium → high when sms/call_log were added
+    // (real address book + SMS body are firmly PII-grade).
+    expect(adapter.dataDisclosure.sensitivity).toBe("high");
     expect(adapter.dataDisclosure.legalGate).toBe(false);
   });
 });
@@ -272,13 +274,29 @@ describe("SystemDataAndroidAdapter — degenerate snapshots", () => {
 // the new path without a real device.
 
 describe("SystemDataAndroidAdapter — bridge-direct sync", () => {
-  function makeBridge({ contacts = [], apps = [], throws = null } = {}) {
+  // Helper accepts every kind the adapter may invoke today (v0.3.0 added
+  // sms / call / media). Unspecified kinds return empty so existing tests
+  // only need to opt-in to the kinds they assert against.
+  function makeBridge({
+    contacts = [],
+    apps = [],
+    sms = [],
+    calls = [],
+    media = {},
+    throws = null,
+  } = {}) {
     return {
       caps: () => ({ available: true, reason: "test" }),
-      invoke: async (method) => {
+      invoke: async (method, params) => {
         if (throws) throw throws;
         if (method === "contacts.query") return { contacts };
         if (method === "app.list") return { apps };
+        if (method === "sms.query") return { sms };
+        if (method === "call.query") return { calls };
+        if (method === "media.list") {
+          const cat = params && params.category;
+          return { files: media[cat] || [] };
+        }
         throw new Error("unexpected method " + method);
       },
     };
@@ -384,4 +402,87 @@ describe("SystemDataAndroidAdapter — bridge-direct sync", () => {
     expect(out).toHaveLength(1);
     expect(out[0].payload.displayName).toBe("From Snapshot");
   });
+
+  // v0.2 — sms/call bridge methods. Validate yields + originalId stability.
+  it("v0.2 bridge yields sms + call rows when present", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () =>
+      makeBridge({
+        sms: [{ id: 7, address: "10086", body: "余额: ¥10", date: 1_700_000_000_000, type: 1 }],
+        calls: [{ id: 9, number: "13900000000", duration: 12, date: 1_700_000_001_000, type: 2 }],
+      });
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true })) out.push(r);
+    expect(out.map((r) => r.kind)).toEqual(["sms", "call"]);
+    expect(out[0].originalId).toBe("android-sms:7");
+    expect(out[1].originalId).toBe("android-call:9");
+  });
+
+  it("v0.2 include.sms=false / include.calls=false honoured per-kind", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () =>
+      makeBridge({
+        sms: [{ id: 1, address: "x", body: "y", date: 1, type: 1 }],
+        calls: [{ id: 2, number: "x", duration: 0, date: 1, type: 1 }],
+      });
+    const noSms = [];
+    for await (const r of adapter.sync({ useBridge: true, include: { sms: false } })) noSms.push(r);
+    expect(noSms.map((r) => r.kind)).toEqual(["call"]);
+    const noCalls = [];
+    for await (const r of adapter.sync({ useBridge: true, include: { calls: false } })) noCalls.push(r);
+    expect(noCalls.map((r) => r.kind)).toEqual(["sms"]);
+  });
+
+  // v0.3 — media files across 5 /sdcard categories.
+  it("v0.3 bridge yields media-file per category with stable originalId", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () =>
+      makeBridge({
+        media: {
+          photos: [{ path: "/sdcard/DCIM/Camera/img.jpg", size: 1234, mtimeMs: 1, ext: "jpg", category: "photos" }],
+          videos: [{ path: "/sdcard/Movies/m.mp4", size: 999, mtimeMs: 2, ext: "mp4", category: "videos" }],
+        },
+      });
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true })) out.push(r);
+    expect(out.map((r) => r.kind)).toEqual(["media-file", "media-file"]);
+    expect(out[0].originalId).toBe("android-media:/sdcard/DCIM/Camera/img.jpg");
+    expect(out[1].originalId).toBe("android-media:/sdcard/Movies/m.mp4");
+  });
+
+  it("v0.3 include.media=false disables ALL media categories", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () =>
+      makeBridge({
+        media: {
+          photos: [{ path: "/p.jpg", category: "photos" }],
+          videos: [{ path: "/v.mp4", category: "videos" }],
+        },
+      });
+    const out = [];
+    for await (const r of adapter.sync({ useBridge: true, include: { media: false } })) {
+      out.push(r);
+    }
+    expect(out).toHaveLength(0);
+  });
+
+  it("v0.3 include.media.photos=false skips just photos, keeps videos", async () => {
+    const adapter = new SystemDataAndroidAdapter();
+    adapter._deps.bridgeProvider = () =>
+      makeBridge({
+        media: {
+          photos: [{ path: "/p.jpg", category: "photos" }],
+          videos: [{ path: "/v.mp4", category: "videos" }],
+        },
+      });
+    const out = [];
+    for await (const r of adapter.sync({
+      useBridge: true,
+      include: { media: { photos: false } },
+    })) {
+      out.push(r);
+    }
+    expect(out).toHaveLength(1);
+    expect(out[0].payload.category).toBe("videos");
+  });
 });

package/__tests__/adapters/vscode.test.js

@@ -0,0 +1,299 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import Database from "better-sqlite3";
+
+const {
+  VSCodeAdapter,
+  VSCODE_NAME,
+  VSCODE_VERSION,
+  decodeFileUri,
+} = require("../../lib/adapters/vscode");
+const { assertAdapter } = require("../../lib/adapter-spec");
+const {
+  ENTITY_TYPES,
+  EVENT_SUBTYPES,
+  ITEM_SUBTYPES,
+} = require("../../lib/constants");
+const { validateEvent, validateItem } = require("../../lib/schemas");
+
+let tmpDir;
+let vscodeRoot;
+let wsRoot;
+let stateDbPath;
+
+function makeWorkspace(hash, folderUri, opts = {}) {
+  const d = join(wsRoot, hash);
+  mkdirSync(d, { recursive: true });
+  const wsFile = join(d, "workspace.json");
+  writeFileSync(wsFile, JSON.stringify({ folder: folderUri }), "utf-8");
+  if (opts.mtimeMs) {
+    const ms = opts.mtimeMs;
+    utimesSync(wsFile, ms / 1000, ms / 1000);
+  }
+}
+
+function makeTerminalHistoryDb({ commands = [], dirs = [], cmdTs = null, dirTs = null }) {
+  mkdirSync(join(vscodeRoot, "User", "globalStorage"), { recursive: true });
+  const db = new Database(stateDbPath);
+  db.exec("CREATE TABLE ItemTable(key TEXT PRIMARY KEY, value BLOB)");
+  const put = db.prepare("INSERT OR REPLACE INTO ItemTable(key, value) VALUES(?, ?)");
+  put.run(
+    "terminal.history.entries.commands",
+    JSON.stringify({
+      entries: commands.map((c) => ({ key: c, value: { shellType: "pwsh" } })),
+    }),
+  );
+  put.run(
+    "terminal.history.entries.dirs",
+    JSON.stringify({
+      entries: dirs.map((d) => ({ key: d, value: { shellType: "pwsh" } })),
+    }),
+  );
+  if (cmdTs != null) put.run("terminal.history.timestamp.commands", String(cmdTs));
+  if (dirTs != null) put.run("terminal.history.timestamp.dirs", String(dirTs));
+  db.close();
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "vscode-adapter-test-"));
+  vscodeRoot = join(tmpDir, "Code");
+  wsRoot = join(vscodeRoot, "User", "workspaceStorage");
+  stateDbPath = join(vscodeRoot, "User", "globalStorage", "state.vscdb");
+  mkdirSync(wsRoot, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("VSCodeAdapter — contract + identity", () => {
+  it("conforms to PersonalDataAdapter contract", () => {
+    expect(assertAdapter(new VSCodeAdapter())).toEqual({ ok: true });
+  });
+
+  it("name/version/capabilities are stable", () => {
+    const a = new VSCodeAdapter();
+    expect(a.name).toBe(VSCODE_NAME);
+    expect(a.name).toBe("vscode");
+    expect(a.version).toBe(VSCODE_VERSION);
+    expect(a.extractMode).toBe("file-import");
+    expect(a.capabilities).toContain("sync:vscode-workspace-storage");
+    expect(a.capabilities).toContain("sync:vscode-globalstorage-sqlite");
+  });
+});
+
+describe("VSCodeAdapter.authenticate", () => {
+  it("VSCODE_NOT_FOUND when neither workspaceStorage nor state.vscdb exist", async () => {
+    rmSync(wsRoot, { recursive: true, force: true });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("VSCODE_NOT_FOUND");
+  });
+
+  it("succeeds when only workspaceStorage exists", async () => {
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(true);
+    expect(r.hasWorkspaces).toBe(true);
+    expect(r.hasTerminalHistory).toBe(false);
+  });
+
+  it("succeeds when only state.vscdb exists", async () => {
+    rmSync(wsRoot, { recursive: true, force: true });
+    makeTerminalHistoryDb({ commands: ["ls"], cmdTs: 1_700_000_000_000 });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(true);
+    expect(r.hasWorkspaces).toBe(false);
+    expect(r.hasTerminalHistory).toBe(true);
+  });
+});
+
+describe("VSCodeAdapter.sync — workspaces", () => {
+  it("yields one raw per workspace.json with folderPath decoded", async () => {
+    makeWorkspace("hash-a", "file:///c%3A/code/foo", { mtimeMs: 1_700_000_001_000 });
+    makeWorkspace("hash-b", "file:///c%3A/code/bar", { mtimeMs: 1_700_000_002_000 });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    const wss = raws.filter((r) => r.kind === "workspace");
+    expect(wss).toHaveLength(2);
+    const byHash = Object.fromEntries(wss.map((r) => [r.payload.hash, r.payload]));
+    expect(byHash["hash-a"].folderUri).toBe("file:///c%3A/code/foo");
+    expect(byHash["hash-a"].folderPath).toMatch(/foo$/);
+    expect(byHash["hash-a"].lastOpenedMs).toBe(1_700_000_001_000);
+  });
+
+  it("filters workspaces by since (uses workspace.json mtime)", async () => {
+    makeWorkspace("old", "file:///c%3A/old", { mtimeMs: 1_700_000_000_000 });
+    makeWorkspace("new", "file:///c%3A/new", { mtimeMs: 1_700_000_005_000 });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync({ since: 1_700_000_003_000 })) raws.push(r);
+    const hashes = raws.filter((r) => r.kind === "workspace").map((r) => r.payload.hash);
+    expect(hashes).toEqual(["new"]);
+  });
+
+  it("skips workspaces with no folder/workspace key", async () => {
+    const d = join(wsRoot, "empty");
+    mkdirSync(d, { recursive: true });
+    writeFileSync(join(d, "workspace.json"), JSON.stringify({}), "utf-8");
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws.filter((r) => r.kind === "workspace")).toHaveLength(0);
+  });
+});
+
+describe("VSCodeAdapter.sync — terminal history", () => {
+  it("yields one raw per command + per dir, anchored to snapshot ts", async () => {
+    makeTerminalHistoryDb({
+      commands: ["ls", "git status", "npm test"],
+      dirs: ["/c/code/foo", "/c/code/bar"],
+      cmdTs: 1_700_000_010_000,
+      dirTs: 1_700_000_020_000,
+    });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    const cmds = raws.filter((r) => r.kind === "terminal-command");
+    const dirs = raws.filter((r) => r.kind === "terminal-dir");
+    expect(cmds).toHaveLength(3);
+    expect(dirs).toHaveLength(2);
+    expect(cmds[0].payload.value).toBe("ls");
+    expect(cmds[0].payload.snapshotTs).toBe(1_700_000_010_000);
+    expect(dirs[0].payload.snapshotTs).toBe(1_700_000_020_000);
+  });
+
+  it("originalId disambiguates duplicate commands by sourceIndex", async () => {
+    makeTerminalHistoryDb({
+      commands: ["ls", "ls"], // duplicate value
+      cmdTs: 1_700_000_010_000,
+    });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    const ids = raws.filter((r) => r.kind === "terminal-command").map((r) => r.originalId);
+    expect(new Set(ids).size).toBe(2);
+  });
+
+  it("respects include.terminal=false", async () => {
+    makeWorkspace("h", "file:///c%3A/p", { mtimeMs: 1_700_000_001_000 });
+    makeTerminalHistoryDb({ commands: ["ls"], cmdTs: 1_700_000_010_000 });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync({ include: { terminal: false } })) raws.push(r);
+    expect(raws.every((r) => r.kind === "workspace")).toBe(true);
+    expect(raws.length).toBe(1);
+  });
+
+  it("respects include.workspaces=false", async () => {
+    makeWorkspace("h", "file:///c%3A/p", { mtimeMs: 1_700_000_001_000 });
+    makeTerminalHistoryDb({ commands: ["ls"], cmdTs: 1_700_000_010_000 });
+    const a = new VSCodeAdapter({ vscodeRoot });
+    const raws = [];
+    for await (const r of a.sync({ include: { workspaces: false } })) raws.push(r);
+    expect(raws.every((r) => r.kind !== "workspace")).toBe(true);
+  });
+});
+
+describe("VSCodeAdapter.normalize", () => {
+  it("maps a workspace to Item(LINK) with code-project category", () => {
+    const a = new VSCodeAdapter();
+    const { items } = a.normalize({
+      kind: "workspace",
+      capturedAt: 1_700_000_000_000,
+      payload: {
+        hash: "h1",
+        folderUri: "file:///c%3A/code/chainlesschain",
+        folderPath: "c:\\code\\chainlesschain",
+        lastOpenedMs: 1_700_000_001_000,
+      },
+    });
+    expect(items).toHaveLength(1);
+    expect(items[0].subtype).toBe(ITEM_SUBTYPES.LINK);
+    expect(items[0].category).toBe("code-project");
+    expect(items[0].name).toBe("chainlesschain");
+    expect(items[0].extra.editor).toBe("vscode");
+    expect(items[0].extra.folderUri).toBe("file:///c%3A/code/chainlesschain");
+    expect(validateItem(items[0]).valid).toBe(true);
+  });
+
+  it("maps terminal-command to Event(OTHER) with cmd in content", () => {
+    const a = new VSCodeAdapter();
+    const { events } = a.normalize({
+      kind: "terminal-command",
+      capturedAt: 1_700_000_000_000,
+      originalId: "vscode-terminal-cmd:0:abc",
+      payload: {
+        value: "git status",
+        shellType: "pwsh",
+        sourceIndex: 0,
+        snapshotTs: 1_700_000_010_000,
+      },
+    });
+    expect(events).toHaveLength(1);
+    expect(events[0].subtype).toBe(EVENT_SUBTYPES.OTHER);
+    expect(events[0].content.title).toBe("git status");
+    expect(events[0].content.text).toBe("git status");
+    expect(events[0].extra.kind).toBe("terminal-command");
+    expect(events[0].extra.shellType).toBe("pwsh");
+    expect(events[0].occurredAt).toBe(1_700_000_010_000);
+    expect(validateEvent(events[0]).valid).toBe(true);
+  });
+
+  it("maps terminal-dir to Event(OTHER) with 'cd <dir>' title", () => {
+    const a = new VSCodeAdapter();
+    const { events } = a.normalize({
+      kind: "terminal-dir",
+      capturedAt: 1_700_000_000_000,
+      originalId: "vscode-terminal-dir:0:xyz",
+      payload: {
+        value: "/c/code/foo",
+        sourceIndex: 0,
+        snapshotTs: 1_700_000_020_000,
+      },
+    });
+    expect(events[0].content.title).toBe("cd /c/code/foo");
+    expect(events[0].extra.kind).toBe("terminal-dir");
+    expect(validateEvent(events[0]).valid).toBe(true);
+  });
+
+  it("truncates >80 char command titles to ellipsis", () => {
+    const a = new VSCodeAdapter();
+    const longCmd = "echo " + "a".repeat(200);
+    const { events } = a.normalize({
+      kind: "terminal-command",
+      capturedAt: 1_700_000_000_000,
+      originalId: "vscode-terminal-cmd:0:long",
+      payload: { value: longCmd, sourceIndex: 0, snapshotTs: 1_700_000_010_000 },
+    });
+    expect(events[0].content.title.length).toBeLessThanOrEqual(81);
+    expect(events[0].content.title.endsWith("…")).toBe(true);
+    expect(events[0].content.text).toBe(longCmd);
+  });
+
+  it("throws on unknown raw.kind", () => {
+    expect(() => new VSCodeAdapter().normalize({ kind: "bogus", payload: {} })).toThrow(
+      /unknown raw\.kind=bogus/,
+    );
+  });
+});
+
+describe("decodeFileUri helper", () => {
+  it("decodes Windows file URI to backslash path", () => {
+    if (process.platform !== "win32") return;
+    expect(decodeFileUri("file:///c%3A/code/foo")).toBe("c:\\code\\foo");
+  });
+
+  it("returns null for non-file:// schemes", () => {
+    expect(decodeFileUri("vscode-remote://ssh-remote+host/foo")).toBe(null);
+    expect(decodeFileUri(null)).toBe(null);
+    expect(decodeFileUri(undefined)).toBe(null);
+  });
+});

package/__tests__/adapters/win-recent.test.js

@@ -0,0 +1,192 @@
+"use strict";
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync, utimesSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const {
+  WinRecentAdapter,
+  WIN_RECENT_NAME,
+  WIN_RECENT_VERSION,
+} = require("../../lib/adapters/win-recent");
+const { assertAdapter } = require("../../lib/adapter-spec");
+const {
+  EVENT_SUBTYPES,
+} = require("../../lib/constants");
+const { validateEvent } = require("../../lib/schemas");
+
+let tmpDir;
+let recentDir;
+
+function makeLnk(name, mtimeMs, body = "lnk-blob") {
+  const p = join(recentDir, name);
+  writeFileSync(p, body, "utf-8");
+  if (mtimeMs != null) {
+    utimesSync(p, mtimeMs / 1000, mtimeMs / 1000);
+  }
+}
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "win-recent-test-"));
+  recentDir = join(tmpDir, "Recent");
+  mkdirSync(recentDir, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("WinRecentAdapter — contract + identity", () => {
+  it("conforms to PersonalDataAdapter contract", () => {
+    expect(assertAdapter(new WinRecentAdapter())).toEqual({ ok: true });
+  });
+
+  it("name + version + capabilities stable", () => {
+    const a = new WinRecentAdapter();
+    expect(a.name).toBe(WIN_RECENT_NAME);
+    expect(a.name).toBe("win-recent");
+    expect(a.version).toBe(WIN_RECENT_VERSION);
+    expect(a.extractMode).toBe("file-import");
+    expect(a.capabilities).toContain("sync:win-recent-shortcuts");
+  });
+});
+
+describe("WinRecentAdapter.authenticate", () => {
+  it("PLATFORM_UNSUPPORTED when no recentDir resolved (override null)", async () => {
+    const a = new WinRecentAdapter();
+    a._deps.defaultDir = () => null;
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("PLATFORM_UNSUPPORTED");
+  });
+
+  it("RECENT_DIR_NOT_FOUND when dir doesn't exist", async () => {
+    const a = new WinRecentAdapter({ recentDir: join(tmpDir, "bogus") });
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe("RECENT_DIR_NOT_FOUND");
+  });
+
+  it("succeeds when dir exists", async () => {
+    const a = new WinRecentAdapter({ recentDir });
+    const r = await a.authenticate({});
+    expect(r.ok).toBe(true);
+    expect(r.recentDir).toBe(recentDir);
+  });
+});
+
+describe("WinRecentAdapter.sync", () => {
+  it("yields one raw per .lnk, sorted mtime ascending", async () => {
+    makeLnk("zebra.lnk", 1_700_000_003_000);
+    makeLnk("apple.lnk", 1_700_000_001_000);
+    makeLnk("mango.lnk", 1_700_000_002_000);
+    const a = new WinRecentAdapter({ recentDir });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws).toHaveLength(3);
+    expect(raws[0].payload.name).toBe("apple");
+    expect(raws[1].payload.name).toBe("mango");
+    expect(raws[2].payload.name).toBe("zebra");
+    expect(raws[0].payload.mtimeMs).toBe(1_700_000_001_000);
+  });
+
+  it("skips non-.lnk files and AutomaticDestinations / CustomDestinations subdirs", async () => {
+    makeLnk("a.lnk", 1_700_000_001_000);
+    makeLnk("readme.txt", 1_700_000_002_000); // non-.lnk
+    mkdirSync(join(recentDir, "AutomaticDestinations"), { recursive: true });
+    writeFileSync(
+      join(recentDir, "AutomaticDestinations", "deep.lnk"),
+      "should-not-be-found",
+    );
+    mkdirSync(join(recentDir, "CustomDestinations"), { recursive: true });
+    const a = new WinRecentAdapter({ recentDir });
+    const raws = [];
+    for await (const r of a.sync()) raws.push(r);
+    expect(raws).toHaveLength(1);
+    expect(raws[0].payload.name).toBe("a");
+  });
+
+  it("respects since filter (epoch ms)", async () => {
+    makeLnk("old.lnk", 1_700_000_001_000);
+    makeLnk("new.lnk", 1_700_000_005_000);
+    const a = new WinRecentAdapter({ recentDir });
+    const raws = [];
+    for await (const r of a.sync({ since: 1_700_000_003_000 })) raws.push(r);
+    expect(raws.map((r) => r.payload.name)).toEqual(["new"]);
+  });
+
+  it("respects limit", async () => {
+    for (let i = 0; i < 10; i++) makeLnk(`f${i}.lnk`, 1_700_000_000_000 + i * 1000);
+    const a = new WinRecentAdapter({ recentDir });
+    const raws = [];
+    for await (const r of a.sync({ limit: 4 })) raws.push(r);
+    expect(raws).toHaveLength(4);
+  });
+
+  it("originalId folds in mtime so same file at new mtime gets a new event", async () => {
+    makeLnk("foo.lnk", 1_700_000_001_000);
+    const a = new WinRecentAdapter({ recentDir });
+    const raws1 = [];
+    for await (const r of a.sync()) raws1.push(r);
+    const id1 = raws1[0].originalId;
+    // Re-touch with a newer mtime
+    makeLnk("foo.lnk", 1_700_000_009_000);
+    const raws2 = [];
+    for await (const r of a.sync()) raws2.push(r);
+    const id2 = raws2[0].originalId;
+    expect(id1).not.toBe(id2);
+    expect(id2).toContain("1700000009000");
+  });
+});
+
+describe("WinRecentAdapter.normalize", () => {
+  it("maps recent-file to Event(OTHER) with '打开了 X' title", () => {
+    const a = new WinRecentAdapter();
+    const { events } = a.normalize({
+      kind: "recent-file",
+      originalId: "win-recent:C:\\Users\\u\\Recent\\foo.lnk:1700000001000",
+      capturedAt: 1_700_000_005_000,
+      payload: {
+        name: "foo",
+        mtimeMs: 1_700_000_001_000,
+        size: 1024,
+        lnkPath: "C:\\Users\\u\\Recent\\foo.lnk",
+      },
+    });
+    expect(events).toHaveLength(1);
+    const e = events[0];
+    expect(e.subtype).toBe(EVENT_SUBTYPES.OTHER);
+    expect(e.content.title).toBe("打开了 foo");
+    expect(e.content.text).toBe("foo");
+    expect(e.actor).toBe("self");
+    expect(e.occurredAt).toBe(1_700_000_001_000);
+    expect(e.extra.kind).toBe("recent-file");
+    expect(e.extra.targetName).toBe("foo");
+    expect(e.extra.source).toBe("win-recent");
+    expect(validateEvent(e).valid).toBe(true);
+  });
+
+  it("truncates long target names in title", () => {
+    const a = new WinRecentAdapter();
+    const longName = "x".repeat(120);
+    const { events } = a.normalize({
+      kind: "recent-file",
+      originalId: "win-recent:long",
+      capturedAt: 1_700_000_000_000,
+      payload: {
+        name: longName,
+        mtimeMs: 1_700_000_000_000,
+      },
+    });
+    // Title is "打开了 " (4 chars) + name; name truncated to 70 + "…"
+    expect(events[0].content.title.endsWith("…")).toBe(true);
+    expect(events[0].content.text).toBe(longName); // full name preserved in text
+  });
+
+  it("throws on unknown raw.kind", () => {
+    expect(() => new WinRecentAdapter().normalize({ kind: "bogus", payload: {} })).toThrow(
+      /unknown raw\.kind=bogus/,
+    );
+  });
+});