recallnest 2.3.0 → 2.6.0

package/src/__tests__/noise-prototype-bank.test.ts

@@ -0,0 +1,280 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { persistMemory } from "../capture-engine.js";
+import {
+  NoisePrototypeBank,
+  isProtectedContent,
+  resetSharedNoisePrototypeBank,
+  resolveNoisePrototypeBank,
+  resolveNoisePrototypeMode,
+} from "../noise-prototype-bank.js";
+
+const cleanupPaths: string[] = [];
+
+afterEach(() => {
+  resetSharedNoisePrototypeBank();
+  while (cleanupPaths.length > 0) {
+    const target = cleanupPaths.pop();
+    if (target) rmSync(target, { recursive: true, force: true });
+  }
+});
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "recallnest-npb-"));
+  cleanupPaths.push(dir);
+  return dir;
+}
+
+function makeBank(overrides: Partial<ConstructorParameters<typeof NoisePrototypeBank>[0]> = {}) {
+  const dir = tempDir();
+  const bank = new NoisePrototypeBank({
+    filePath: join(dir, "bank.json"),
+    shadowLogPath: join(dir, "shadow.jsonl"),
+    ...overrides,
+  });
+  return { bank, dir };
+}
+
+// Deterministic fake embedder: unit vectors along an axis picked by seed.
+function axisVector(axis: number, dim = 8): number[] {
+  const v = new Array(dim).fill(0);
+  v[axis] = 1;
+  return v;
+}
+
+const embedAxis0 = async () => axisVector(0);
+
+describe("NoisePrototypeBank — learning discipline", () => {
+  it("first rejection is only a pending candidate; the repeat sighting learns", async () => {
+    const { bank } = makeBank();
+    expect(await bank.learnFromRejection("嗯嗯嗯嗯好的好的", embedAxis0)).toBe("candidate_seen");
+    expect(bank.list().length).toBe(0);
+    expect(bank.pendingCount()).toBe(1);
+
+    expect(await bank.learnFromRejection("嗯嗯嗯嗯好的好的", embedAxis0)).toBe("learned");
+    expect(bank.list().length).toBe(1);
+    expect(bank.pendingCount()).toBe(0);
+    expect(bank.list()[0]?.seenCount).toBe(2);
+  });
+
+  it("normalization dedupes near-identical rejections into one candidate", async () => {
+    const { bank } = makeBank();
+    await bank.learnFromRejection("嗯嗯嗯嗯好的好的", embedAxis0);
+    // Same content modulo whitespace/punctuation/case → same candidate.
+    expect(await bank.learnFromRejection("嗯嗯嗯嗯,好的 好的!!", embedAxis0)).toBe("learned");
+  });
+
+  it("already-learned content reports skipped_duplicate without re-embedding", async () => {
+    const { bank } = makeBank();
+    let embeds = 0;
+    const countingEmbed = async () => {
+      embeds += 1;
+      return axisVector(0);
+    };
+    await bank.learnFromRejection("嗯嗯嗯嗯好的好的", countingEmbed);
+    await bank.learnFromRejection("嗯嗯嗯嗯好的好的", countingEmbed);
+    expect(embeds).toBe(1);
+    expect(await bank.learnFromRejection("嗯嗯嗯嗯好的好的", countingEmbed)).toBe("skipped_duplicate");
+    expect(embeds).toBe(1);
+  });
+
+  it("protected content is never learned, even when the noise filter rejected it", async () => {
+    const { bank } = makeBank();
+    expect(await bank.learnFromRejection("记住我喜欢的部署方式", embedAxis0)).toBe("skipped_protected");
+    expect(await bank.learnFromRejection("记住我喜欢的部署方式", embedAxis0)).toBe("skipped_protected");
+    expect(bank.list().length).toBe(0);
+    expect(bank.pendingCount()).toBe(0);
+  });
+
+  it("the cap stops learning at maxPrototypes", async () => {
+    const { bank } = makeBank({ maxPrototypes: 1, minSeenCount: 1 });
+    expect(await bank.learnFromRejection("噪声内容甲甲甲甲", embedAxis0)).toBe("learned");
+    expect(await bank.learnFromRejection("噪声内容乙乙乙乙", embedAxis0)).toBe("skipped_full");
+    expect(bank.list().length).toBe(1);
+  });
+});
+
+describe("NoisePrototypeBank — shadow matching", () => {
+  async function seededBank() {
+    const made = makeBank({ minSeenCount: 1 });
+    await made.bank.learnFromRejection("嗯嗯嗯嗯好的好的", embedAxis0);
+    return made;
+  }
+
+  it("similarity at/above threshold suggests rejection and logs, but only logs", async () => {
+    const { bank, dir } = await seededBank();
+    const match = bank.matchShadow("嗯嗯好的收到啦", axisVector(0), "mem-123");
+    expect(match.matched).toBe(true);
+    expect(match.similarity).toBeCloseTo(1, 5);
+    expect(bank.list()[0]?.hitCount).toBe(1);
+
+    const log = readFileSync(join(dir, "shadow.jsonl"), "utf8").trim().split("\n");
+    const suggest = log.map((l) => JSON.parse(l)).find((e) => e.event === "suggest_reject");
+    expect(suggest?.memoryId).toBe("mem-123");
+    expect(suggest?.prototypeId).toBe(bank.list()[0]?.id);
+    expect(JSON.stringify(suggest)).not.toContain("嗯嗯好的收到啦");
+  });
+
+  it("below-threshold similarity does not match", async () => {
+    const { bank } = await seededBank();
+    const match = bank.matchShadow("完全不同的正交内容", axisVector(1));
+    expect(match.matched).toBe(false);
+    expect(bank.list()[0]?.hitCount).toBe(0);
+  });
+
+  it("protected content is never flagged regardless of similarity", async () => {
+    const { bank } = await seededBank();
+    const match = bank.matchShadow("记住我喜欢的部署方式", axisVector(0));
+    expect(match.matched).toBe(false);
+    expect(match.protected).toBe(true);
+  });
+
+  it("dimension mismatch degrades to no match instead of throwing", async () => {
+    const { bank } = await seededBank();
+    const match = bank.matchShadow("维度不齐的向量", [1, 0]);
+    expect(match.matched).toBe(false);
+  });
+});
+
+describe("NoisePrototypeBank — correction & lifecycle", () => {
+  it("removePrototype surgically deletes one false positive", async () => {
+    const { bank } = makeBank({ minSeenCount: 1 });
+    await bank.learnFromRejection("噪声内容甲甲甲甲", embedAxis0);
+    const id = bank.list()[0]?.id ?? "";
+    expect(bank.removePrototype(id)).toBe(true);
+    expect(bank.list().length).toBe(0);
+    expect(bank.removePrototype(id)).toBe(false);
+  });
+
+  it("clear resets everything", async () => {
+    const { bank } = makeBank({ minSeenCount: 1 });
+    await bank.learnFromRejection("噪声内容甲甲甲甲", embedAxis0);
+    bank.clear();
+    expect(bank.list().length).toBe(0);
+  });
+
+  it("state survives reconstruction from disk; expired prototypes are swept", async () => {
+    const { bank, dir } = makeBank({ minSeenCount: 1 });
+    await bank.learnFromRejection("噪声内容甲甲甲甲", embedAxis0);
+
+    const reloaded = new NoisePrototypeBank({
+      filePath: join(dir, "bank.json"),
+      shadowLogPath: join(dir, "shadow.jsonl"),
+    });
+    expect(reloaded.list().length).toBe(1);
+
+    // Age the stored prototype past the TTL, then reload.
+    const raw = JSON.parse(readFileSync(join(dir, "bank.json"), "utf8"));
+    raw.prototypes[0].learnedAt = "2020-01-01T00:00:00.000Z";
+    writeFileSync(join(dir, "bank.json"), JSON.stringify(raw), "utf8");
+    const expiring = new NoisePrototypeBank({
+      filePath: join(dir, "bank.json"),
+      shadowLogPath: join(dir, "shadow.jsonl"),
+    });
+    expect(expiring.list().length).toBe(0);
+  });
+});
+
+describe("isProtectedContent", () => {
+  it("covers memory verbs, corrections, decisions, identity, preferences", () => {
+    for (const text of ["记住这个", "帮我记一下", "纠正一下,不对", "我决定用方案B", "我是安闲静雅", "我喜欢深色主题", "i prefer dark mode", "remember this setup"]) {
+      expect(`${text}:${isProtectedContent(text)}`).toBe(`${text}:true`);
+    }
+    for (const text of ["嗯嗯好的", "git push", "今天天气不错"]) {
+      expect(`${text}:${isProtectedContent(text)}`).toBe(`${text}:false`);
+    }
+  });
+});
+
+describe("resolveNoisePrototypeMode / shared bank resolution", () => {
+  it("defaults to shadow in production, off under NODE_ENV=test unless explicit", () => {
+    expect(resolveNoisePrototypeMode({} as NodeJS.ProcessEnv)).toBe("shadow");
+    expect(resolveNoisePrototypeMode({ NODE_ENV: "test" } as NodeJS.ProcessEnv)).toBe("off");
+    expect(resolveNoisePrototypeMode({ NODE_ENV: "test", RECALLNEST_NOISE_PROTOTYPE: "shadow" } as NodeJS.ProcessEnv)).toBe("shadow");
+    expect(resolveNoisePrototypeMode({ RECALLNEST_NOISE_PROTOTYPE: "off" } as NodeJS.ProcessEnv)).toBe("off");
+    expect(resolveNoisePrototypeMode({ RECALLNEST_NOISE_PROTOTYPE: "banana" } as NodeJS.ProcessEnv)).toBe("shadow");
+  });
+
+  it("explicit deps win over the env-governed shared instance", () => {
+    const { bank } = makeBank();
+    expect(resolveNoisePrototypeBank(bank)).toBe(bank);
+    expect(resolveNoisePrototypeBank(null)).toBeNull();
+    // Under bun test (NODE_ENV=test, no explicit env) the shared bank is off.
+    expect(resolveNoisePrototypeBank(undefined)).toBeNull();
+  });
+});
+
+// --- integration through persistMemory ---
+
+function makePersistDeps(bank: NoisePrototypeBank | null) {
+  const storeCalls: unknown[] = [];
+  return {
+    storeCalls,
+    deps: {
+      embedder: {
+        async embedPassage() {
+          return axisVector(0);
+        },
+      },
+      store: {
+        async store(entry: Record<string, unknown>) {
+          storeCalls.push(entry);
+          return { ...entry, id: `mem-${storeCalls.length}`, timestamp: Date.now() };
+        },
+      },
+      noisePrototypeBank: bank,
+    },
+  };
+}
+
+describe("persistMemory × noise-prototype shadow", () => {
+  it("noise_detected rejection feeds the bank; the write is still rejected", async () => {
+    const { bank } = makeBank({ minSeenCount: 1 });
+    const { deps } = makePersistDeps(bank);
+
+    const result = await persistMemory(deps as never, {
+      text: "hello world, how are you today?",
+      category: "events",
+      importance: 0.7,
+      scope: "project:npb-test",
+      source: "manual",
+    });
+
+    expect(result.disposition).toBe("rejected");
+    expect(result.rejectionReason).toBe("noise_detected");
+    expect(bank.list().length).toBe(1); // minSeenCount 1 → learned immediately
+  });
+
+  it("accepted writes run the shadow match against the write-path vector", async () => {
+    const { bank, dir } = makeBank({ minSeenCount: 1 });
+    await bank.learnFromRejection("噪声原型种子内容", embedAxis0);
+    const { deps } = makePersistDeps(bank);
+
+    const result = await persistMemory(deps as never, {
+      text: "RecallNest 的 readConsistencyInterval 已经默认为 0",
+      category: "events",
+      importance: 0.7,
+      scope: "project:npb-test",
+      source: "manual",
+    });
+
+    expect(result.disposition).not.toBe("rejected");
+    const log = readFileSync(join(dir, "shadow.jsonl"), "utf8");
+    expect(log).toContain("suggest_reject"); // axis-0 fake vectors always collide
+  });
+
+  it("bank=null disables both sides completely", async () => {
+    const { deps } = makePersistDeps(null);
+    const result = await persistMemory(deps as never, {
+      text: "hello world, how are you today?",
+      category: "events",
+      importance: 0.7,
+      scope: "project:npb-test",
+      source: "manual",
+    });
+    expect(result.disposition).toBe("rejected"); // admission unchanged
+  });
+});

package/src/__tests__/obsidian-connector.test.ts

@@ -0,0 +1,363 @@
+import { describe, expect, it, beforeAll, afterAll } from "bun:test";
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  isObsidianVault,
+  parseFrontmatter,
+  extractWikiLinks,
+  contentHash,
+  scanVault,
+} from "../obsidian-connector.js";
+
+// ---------------------------------------------------------------------------
+// Temp vault fixture
+// ---------------------------------------------------------------------------
+
+const VAULT_ROOT = join(tmpdir(), `recallnest-obsidian-test-${Date.now()}`);
+
+beforeAll(() => {
+  // Create vault structure
+  mkdirSync(join(VAULT_ROOT, ".obsidian"), { recursive: true });
+  mkdirSync(join(VAULT_ROOT, "projects"), { recursive: true });
+  mkdirSync(join(VAULT_ROOT, "daily"), { recursive: true });
+  mkdirSync(join(VAULT_ROOT, ".trash"), { recursive: true });
+
+  // Root-level note with frontmatter + wikilinks
+  writeFileSync(
+    join(VAULT_ROOT, "My Note.md"),
+    `---
+tags: [ai, memory]
+aliases: [note-1]
+status: active
+---
+
+# My Note
+
+This is a note about [[RecallNest]] and [[LanceDB|vector database]].
+
+Some more content here to make it long enough.
+`,
+  );
+
+  // Nested note in projects/
+  writeFileSync(
+    join(VAULT_ROOT, "projects", "Project Alpha.md"),
+    `---
+tags:
+  - project
+  - alpha
+priority: high
+---
+
+# Project Alpha
+
+Working on [[Feature X]] for [[Project Alpha]].
+
+Details about the project implementation and design decisions.
+`,
+  );
+
+  // Daily note without frontmatter
+  writeFileSync(
+    join(VAULT_ROOT, "daily", "2026-04-13.md"),
+    `# 2026-04-13
+
+- Met with team about [[Q2 Goals]]
+- Reviewed [[PR #123]]
+- Need to follow up on [[Budget Review]]
+
+Some additional notes about the day and what happened.
+`,
+  );
+
+  // Short note (should be skipped)
+  writeFileSync(join(VAULT_ROOT, "short.md"), "Hi");
+
+  // Trash note (should be skipped)
+  writeFileSync(
+    join(VAULT_ROOT, ".trash", "deleted.md"),
+    "This is deleted content that should not be ingested into the vault.\n",
+  );
+});
+
+afterAll(() => {
+  try {
+    rmSync(VAULT_ROOT, { recursive: true, force: true });
+  } catch {
+    // cleanup best-effort
+  }
+});
+
+// ---------------------------------------------------------------------------
+// isObsidianVault
+// ---------------------------------------------------------------------------
+
+describe("isObsidianVault", () => {
+  it("returns true for a directory with .obsidian/", () => {
+    expect(isObsidianVault(VAULT_ROOT)).toBe(true);
+  });
+
+  it("returns false for a regular directory", () => {
+    expect(isObsidianVault(join(VAULT_ROOT, "projects"))).toBe(false);
+  });
+
+  it("returns false for non-existent directory", () => {
+    expect(isObsidianVault("/nonexistent/path")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// parseFrontmatter
+// ---------------------------------------------------------------------------
+
+describe("parseFrontmatter", () => {
+  it("parses inline list tags", () => {
+    const content = `---
+tags: [ai, memory]
+status: active
+---
+
+Body content here.`;
+    const { frontmatter, body } = parseFrontmatter(content);
+    expect(frontmatter).not.toBeNull();
+    expect(frontmatter!.tags).toEqual(["ai", "memory"]);
+    expect(frontmatter!.status).toBe("active");
+    expect(body).toBe("Body content here.");
+  });
+
+  it("parses YAML list tags", () => {
+    const content = `---
+tags:
+  - project
+  - alpha
+priority: high
+---
+
+Body here.`;
+    const { frontmatter, body } = parseFrontmatter(content);
+    expect(frontmatter).not.toBeNull();
+    expect(frontmatter!.tags).toEqual(["project", "alpha"]);
+    expect(frontmatter!.priority).toBe("high");
+    expect(body).toBe("Body here.");
+  });
+
+  it("returns null frontmatter when no --- block", () => {
+    const content = "# Just a heading\n\nSome content.";
+    const { frontmatter, body } = parseFrontmatter(content);
+    expect(frontmatter).toBeNull();
+    expect(body).toBe(content);
+  });
+
+  it("handles empty frontmatter", () => {
+    const content = `---
+---
+
+Body.`;
+    const { frontmatter, body } = parseFrontmatter(content);
+    expect(frontmatter).toBeNull();
+    expect(body).toBe("Body.");
+  });
+
+  it("handles quoted values", () => {
+    const content = `---
+title: 'My Title'
+author: "Alice"
+---
+
+Content.`;
+    const { frontmatter } = parseFrontmatter(content);
+    expect(frontmatter).not.toBeNull();
+    expect(frontmatter!.title).toBe("My Title");
+    expect(frontmatter!.author).toBe("Alice");
+  });
+
+  it("handles empty inline list []", () => {
+    const content = `---
+tags: []
+---
+
+Content here is long enough.`;
+    const { frontmatter } = parseFrontmatter(content);
+    // Empty list should not produce tags
+    expect(frontmatter).toBeNull();
+  });
+
+  it("handles Windows-style line endings", () => {
+    const content = "---\r\ntags: [a, b]\r\n---\r\n\r\nBody.";
+    const { frontmatter, body } = parseFrontmatter(content);
+    expect(frontmatter).not.toBeNull();
+    expect(frontmatter!.tags).toEqual(["a", "b"]);
+    expect(body).toBe("Body.");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// extractWikiLinks
+// ---------------------------------------------------------------------------
+
+describe("extractWikiLinks", () => {
+  it("extracts simple wikilinks", () => {
+    const links = extractWikiLinks("Link to [[RecallNest]] and [[LanceDB]].");
+    expect(links).toHaveLength(2);
+    expect(links[0].target).toBe("RecallNest");
+    expect(links[1].target).toBe("LanceDB");
+  });
+
+  it("extracts wikilinks with display text", () => {
+    const links = extractWikiLinks("See [[LanceDB|vector database]] for details.");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("LanceDB");
+    expect(links[0].displayText).toBe("vector database");
+  });
+
+  it("skips embed syntax ![[embed]]", () => {
+    const links = extractWikiLinks("Normal [[link]] and embed ![[image.png]].");
+    expect(links).toHaveLength(1);
+    expect(links[0].target).toBe("link");
+  });
+
+  it("handles multiple links on same line", () => {
+    const links = extractWikiLinks("[[A]] connects to [[B]] and [[C]]");
+    expect(links).toHaveLength(3);
+  });
+
+  it("returns empty array for no links", () => {
+    const links = extractWikiLinks("Just plain text.");
+    expect(links).toHaveLength(0);
+  });
+
+  it("trims whitespace from targets", () => {
+    const links = extractWikiLinks("[[ Spaced Target ]]");
+    expect(links[0].target).toBe("Spaced Target");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// contentHash
+// ---------------------------------------------------------------------------
+
+describe("contentHash", () => {
+  it("returns a 16-char hex string", () => {
+    const hash = contentHash("hello world");
+    expect(hash).toHaveLength(16);
+    expect(/^[0-9a-f]{16}$/.test(hash)).toBe(true);
+  });
+
+  it("is deterministic", () => {
+    expect(contentHash("same input")).toBe(contentHash("same input"));
+  });
+
+  it("differs for different inputs", () => {
+    expect(contentHash("input A")).not.toBe(contentHash("input B"));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// scanVault
+// ---------------------------------------------------------------------------
+
+describe("scanVault", () => {
+  it("produces valid connector-v1 output", () => {
+    const output = scanVault(VAULT_ROOT);
+    expect(output.version).toBe("connector-v1");
+    expect(output.source).toBe("obsidian");
+    expect(output.scope).toContain("vault:");
+    expect(Array.isArray(output.records)).toBe(true);
+  });
+
+  it("finds all non-short, non-excluded .md files", () => {
+    const output = scanVault(VAULT_ROOT);
+    // Should find: My Note.md, projects/Project Alpha.md, daily/2026-04-13.md
+    // Should NOT find: short.md (too short), .trash/deleted.md (excluded)
+    expect(output.records).toHaveLength(3);
+  });
+
+  it("extracts frontmatter tags", () => {
+    const output = scanVault(VAULT_ROOT);
+    const myNote = output.records.find((r) => r.id === "obsidian:My Note.md");
+    expect(myNote).toBeDefined();
+    expect(myNote!.tags).toContain("ai");
+    expect(myNote!.tags).toContain("memory");
+  });
+
+  it("extracts wikilinks as link: tags", () => {
+    const output = scanVault(VAULT_ROOT);
+    const myNote = output.records.find((r) => r.id === "obsidian:My Note.md");
+    expect(myNote).toBeDefined();
+    expect(myNote!.tags).toContain("link:RecallNest");
+    expect(myNote!.tags).toContain("link:LanceDB");
+  });
+
+  it("maps folder structure to folder: tags", () => {
+    const output = scanVault(VAULT_ROOT);
+    const projectNote = output.records.find((r) => r.id?.includes("projects/"));
+    expect(projectNote).toBeDefined();
+    expect(projectNote!.tags).toContain("folder:projects");
+  });
+
+  it("does not add folder: tag for root-level files", () => {
+    const output = scanVault(VAULT_ROOT);
+    const myNote = output.records.find((r) => r.id === "obsidian:My Note.md");
+    expect(myNote).toBeDefined();
+    const folderTags = myNote!.tags!.filter((t) => t.startsWith("folder:"));
+    expect(folderTags).toHaveLength(0);
+  });
+
+  it("skips .trash and .obsidian directories", () => {
+    const output = scanVault(VAULT_ROOT);
+    const trashNote = output.records.find((r) => r.id?.includes(".trash"));
+    expect(trashNote).toBeUndefined();
+  });
+
+  it("computes contentHash for each record", () => {
+    const output = scanVault(VAULT_ROOT);
+    for (const record of output.records) {
+      expect(record.contentHash).toBeDefined();
+      expect(record.contentHash!).toHaveLength(16);
+    }
+  });
+
+  it("includes sourceMetadata with vault info", () => {
+    const output = scanVault(VAULT_ROOT);
+    const myNote = output.records.find((r) => r.id === "obsidian:My Note.md");
+    expect(myNote!.sourceMetadata).toBeDefined();
+    expect(myNote!.sourceMetadata!.vaultPath).toBe(VAULT_ROOT);
+    expect(myNote!.sourceMetadata!.relativePath).toBe("My Note.md");
+    expect(myNote!.sourceMetadata!.frontmatter).toBeDefined();
+    expect(myNote!.sourceMetadata!.wikiLinks).toBeDefined();
+  });
+
+  it("respects custom scopePrefix", () => {
+    const output = scanVault(VAULT_ROOT, { scopePrefix: "custom:my-vault" });
+    expect(output.scope).toBe("custom:my-vault");
+  });
+
+  it("respects custom excludeDirs", () => {
+    // Exclude 'daily' directory
+    const output = scanVault(VAULT_ROOT, {
+      excludeDirs: [".obsidian", ".trash", ".git", "node_modules", "daily"],
+    });
+    const dailyNote = output.records.find((r) => r.id?.includes("daily/"));
+    expect(dailyNote).toBeUndefined();
+    // Should still find the other 2
+    expect(output.records).toHaveLength(2);
+  });
+
+  it("strips frontmatter from body text", () => {
+    const output = scanVault(VAULT_ROOT);
+    const myNote = output.records.find((r) => r.id === "obsidian:My Note.md");
+    expect(myNote!.text).not.toContain("---");
+    expect(myNote!.text).toContain("# My Note");
+  });
+
+  it("handles note without frontmatter", () => {
+    const output = scanVault(VAULT_ROOT);
+    const dailyNote = output.records.find((r) => r.id?.includes("2026-04-13"));
+    expect(dailyNote).toBeDefined();
+    // Should still extract wikilinks
+    expect(dailyNote!.tags).toContain("link:Q2 Goals");
+    expect(dailyNote!.tags).toContain("link:PR #123");
+  });
+});