@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/plugins/defaults/memory/substrate/__tests__/ingest.test.ts

@@ -0,0 +1,440 @@
+/**
+ * Tests for `substrate/ingest.ts`.
+ *
+ * Coverage matrix:
+ *   - Happy path: N valid pages written, both reindex job types enqueued once.
+ *   - Dry-run: nothing on disk, no lock file, no enqueues, per-page results
+ *     still reported.
+ *   - Collision: existing slug skipped without `overwrite`, rewritten with it.
+ *   - Malformed page (bad frontmatter YAML, schema failure, unterminated
+ *     fence): `invalid` with an error string while valid batch-mates write.
+ *   - Lock held by a live PID: IngestLockedError, zero writes, zero enqueues.
+ *   - Batch over the cap: RangeError.
+ *   - In-batch duplicate slug: later occurrence `invalid`.
+ *   - Non-blocking warnings: missing `source`, unparseable `origin_date`,
+ *     frontmatter `slug` differing from the storage slug.
+ *   - Under-lock collision snapshot: a page committed between validation and
+ *     the write phase is skipped, and `listPages` runs after `tryAcquireLock`.
+ *   - Partial write failure: the reindex fan-out still runs for committed
+ *     pages while the write error propagates.
+ *
+ * Tests use temp workspaces (mkdtemp) and never touch `~/.vellum/`. Sample
+ * content uses generic placeholders (Alice).
+ */
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── jobs-store mock ─────────────────────────────────────────────────
+//
+// The ingest service enqueues reindex follow-ups through the shared memory
+// job queue; an in-memory recorder stands in for the DB so the tests can
+// assert the fan-out without initializing sqlite.
+const enqueuedJobs: Array<{
+  type: string;
+  payload: Record<string, unknown>;
+}> = [];
+let nextJobIdCounter = 0;
+// Job types the service should see as already pending; drives the
+// enqueue-coalescing branch (`hasPendingJobOfType`).
+let pendingJobTypes = new Set<string>();
+
+mock.module("../../../../../persistence/jobs-store.js", () => ({
+  enqueueMemoryJob: (
+    type: string,
+    payload: Record<string, unknown>,
+  ): string => {
+    enqueuedJobs.push({ type, payload });
+    nextJobIdCounter += 1;
+    return `job-${nextJobIdCounter}`;
+  },
+  hasPendingJobOfType: (type: string): boolean => pendingJobTypes.has(type),
+  isMemoryEnabled: () => true,
+}));
+
+// ── page-store / consolidation-lock delegating mocks ────────────────
+//
+// Thin wrappers around the real modules that record the ordering of lock
+// acquisition vs the collision snapshot and expose two race hooks: a
+// callback fired right after the lock is acquired (simulating a concurrent
+// writer that committed just before the snapshot) and a set of slugs whose
+// `writePage` rejects (simulating a mid-batch write failure).
+//
+// `mock.module` mutates the already-imported namespace objects in place, so
+// the wrapped functions are snapshotted into standalone consts first; calling
+// through the namespace after mocking would recurse into the wrapper.
+const realPageStore = await import("../page-store.js");
+const realLock = await import("../consolidation-lock.js");
+const realListPages = realPageStore.listPages;
+const realWritePage = realPageStore.writePage;
+const realTryAcquireLock = realLock.tryAcquireLock;
+
+const callTrace: string[] = [];
+let onLockAcquired: (() => void) | undefined;
+let failWriteSlugs = new Set<string>();
+
+mock.module("../page-store.js", () => ({
+  ...realPageStore,
+  listPages: (workspaceDir: string): Promise<string[]> => {
+    callTrace.push("listPages");
+    return realListPages(workspaceDir);
+  },
+  writePage: (...args: Parameters<typeof realWritePage>): Promise<void> => {
+    if (failWriteSlugs.has(args[1].slug)) {
+      return Promise.reject(
+        new Error(`simulated write failure: ${args[1].slug}`),
+      );
+    }
+    return realWritePage(...args);
+  },
+}));
+
+mock.module("../consolidation-lock.js", () => ({
+  ...realLock,
+  tryAcquireLock: (
+    ...args: Parameters<typeof realTryAcquireLock>
+  ): string | null => {
+    const holder = realTryAcquireLock(...args);
+    if (holder === null) {
+      callTrace.push("tryAcquireLock");
+      onLockAcquired?.();
+    }
+    return holder;
+  },
+}));
+
+const { IngestLockedError, ingestPages, MAX_INGEST_PAGES_PER_CALL } =
+  await import("../ingest.js");
+const { getConsolidationLockPath } = await import("../consolidation-lock.js");
+const { listPages, readPage } = await import("../page-store.js");
+
+let workspace: string;
+
+beforeEach(() => {
+  workspace = mkdtempSync(join(tmpdir(), "memory-ingest-test-"));
+  enqueuedJobs.length = 0;
+  pendingJobTypes = new Set();
+  callTrace.length = 0;
+  onLockAcquired = undefined;
+  failWriteSlugs = new Set();
+});
+
+afterEach(() => {
+  rmSync(workspace, { recursive: true, force: true });
+});
+
+/** A well-formed page carrying provenance so it yields zero warnings. */
+function validPage(body: string): string {
+  return `---\nsource: import:chatgpt\norigin_date: 2025-03-14\n---\n${body}\n`;
+}
+
+function lockPath(): string {
+  return getConsolidationLockPath(join(workspace, "memory"));
+}
+
+describe("ingestPages", () => {
+  test("happy path writes every page and enqueues both reindex jobs once", async () => {
+    const summary = await ingestPages(workspace, [
+      { slug: "people/alice", content: validPage("Alice likes hiking.") },
+      { slug: "projects/garden", content: validPage("Garden redesign notes.") },
+      { slug: "recipes", content: validPage("Favorite recipes.") },
+    ]);
+
+    expect(summary.written).toBe(3);
+    expect(summary.skipped).toBe(0);
+    expect(summary.invalid).toBe(0);
+    expect(summary.dryRun).toBe(false);
+    expect(summary.results.map((r) => r.action)).toEqual([
+      "written",
+      "written",
+      "written",
+    ]);
+    expect(summary.results.every((r) => r.warnings.length === 0)).toBe(true);
+
+    const alice = await readPage(workspace, "people/alice");
+    expect(alice?.body.trim()).toBe("Alice likes hiking.");
+    expect(alice?.frontmatter.source).toBe("import:chatgpt");
+    expect(await listPages(workspace)).toEqual([
+      "people/alice",
+      "projects/garden",
+      "recipes",
+    ]);
+
+    expect(enqueuedJobs.map((j) => j.type).sort()).toEqual([
+      "memory_v2_reembed",
+      "memory_v3_maintain",
+    ]);
+    // The lock is released after the batch.
+    expect(existsSync(lockPath())).toBe(false);
+  });
+
+  test("dry-run reports per-page results without disk writes, lock, or enqueues", async () => {
+    const summary = await ingestPages(
+      workspace,
+      [
+        { slug: "people/alice", content: validPage("Alice likes hiking.") },
+        { slug: "bad slug", content: validPage("whitespace slug") },
+      ],
+      { dryRun: true },
+    );
+
+    expect(summary.dryRun).toBe(true);
+    expect(summary.written).toBe(1);
+    expect(summary.invalid).toBe(1);
+    expect(summary.results[0]).toMatchObject({
+      slug: "people/alice",
+      action: "written",
+    });
+    expect(summary.results[1].action).toBe("invalid");
+    expect(summary.results[1].error).toContain("whitespace");
+
+    expect(await listPages(workspace)).toEqual([]);
+    expect(existsSync(lockPath())).toBe(false);
+    expect(enqueuedJobs).toEqual([]);
+  });
+
+  test("existing slug is skipped without overwrite and rewritten with it", async () => {
+    await ingestPages(workspace, [
+      { slug: "people/alice", content: validPage("Original body.") },
+    ]);
+    enqueuedJobs.length = 0;
+
+    const skipped = await ingestPages(workspace, [
+      { slug: "people/alice", content: validPage("Replacement body.") },
+    ]);
+    expect(skipped.results[0].action).toBe("skipped_exists");
+    expect(skipped.written).toBe(0);
+    expect(skipped.skipped).toBe(1);
+    const unchanged = await readPage(workspace, "people/alice");
+    expect(unchanged?.body.trim()).toBe("Original body.");
+    // Nothing written, so no reindex fan-out.
+    expect(enqueuedJobs).toEqual([]);
+
+    const overwritten = await ingestPages(
+      workspace,
+      [{ slug: "people/alice", content: validPage("Replacement body.") }],
+      { overwrite: true },
+    );
+    expect(overwritten.results[0].action).toBe("written");
+    const replaced = await readPage(workspace, "people/alice");
+    expect(replaced?.body.trim()).toBe("Replacement body.");
+  });
+
+  test("malformed pages are invalid with an error string while valid batch-mates write", async () => {
+    const summary = await ingestPages(workspace, [
+      // Broken YAML inside the fence.
+      { slug: "broken-yaml", content: "---\nedges: [unclosed\n---\nbody\n" },
+      // Well-formed YAML that fails the frontmatter schema (edges must be an array).
+      { slug: "schema-fail", content: "---\nedges: not-an-array\n---\nbody\n" },
+      // Fence that opens but never closes (degraded parse).
+      { slug: "unterminated", content: "---\nsource: import:chatgpt\nbody\n" },
+      { slug: "good", content: validPage("Survives the batch.") },
+    ]);
+
+    expect(summary.invalid).toBe(3);
+    expect(summary.written).toBe(1);
+    for (const result of summary.results.slice(0, 3)) {
+      expect(result.action).toBe("invalid");
+      expect(typeof result.error).toBe("string");
+      expect(result.error!.length).toBeGreaterThan(0);
+    }
+    expect(summary.results[2].error).toContain("closing --- fence is missing");
+
+    expect(await listPages(workspace)).toEqual(["good"]);
+    expect(enqueuedJobs.map((j) => j.type).sort()).toEqual([
+      "memory_v2_reembed",
+      "memory_v3_maintain",
+    ]);
+  });
+
+  test("held lock throws IngestLockedError with the holder and writes nothing", async () => {
+    const path = lockPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const holderPayload = `${process.pid} ${Date.now()} consolidation`;
+    writeFileSync(path, `${holderPayload}\n`);
+
+    let thrown: unknown;
+    try {
+      await ingestPages(workspace, [
+        { slug: "people/alice", content: validPage("Alice likes hiking.") },
+      ]);
+    } catch (err) {
+      thrown = err;
+    }
+    expect(thrown).toBeInstanceOf(IngestLockedError);
+    expect((thrown as InstanceType<typeof IngestLockedError>).holder).toBe(
+      holderPayload,
+    );
+
+    expect(await listPages(workspace)).toEqual([]);
+    expect(enqueuedJobs).toEqual([]);
+    // The pre-existing lock is left in place for its holder.
+    expect(existsSync(path)).toBe(true);
+  });
+
+  test("batch over the cap throws RangeError before any validation", async () => {
+    const pages = Array.from(
+      { length: MAX_INGEST_PAGES_PER_CALL + 1 },
+      (_, i) => ({ slug: `page-${i}`, content: validPage(`Body ${i}.`) }),
+    );
+    await expect(ingestPages(workspace, pages)).rejects.toBeInstanceOf(
+      RangeError,
+    );
+    expect(await listPages(workspace)).toEqual([]);
+  });
+
+  test("in-batch duplicate slug is invalid; the first occurrence wins", async () => {
+    const summary = await ingestPages(workspace, [
+      { slug: "people/alice", content: validPage("First occurrence.") },
+      { slug: "people/alice", content: validPage("Second occurrence.") },
+    ]);
+
+    expect(summary.written).toBe(1);
+    expect(summary.invalid).toBe(1);
+    expect(summary.results[1].action).toBe("invalid");
+    expect(summary.results[1].error).toContain("duplicate slug");
+    const page = await readPage(workspace, "people/alice");
+    expect(page?.body.trim()).toBe("First occurrence.");
+  });
+
+  test("slugs under synthetic capability prefixes are invalid, not written", async () => {
+    const summary = await ingestPages(workspace, [
+      { slug: "skills/browser", content: validPage("Shadowed skill page.") },
+      { slug: "cli-commands/memory", content: validPage("Shadowed CLI page.") },
+      { slug: "people/alice", content: validPage("Normal page.") },
+    ]);
+
+    expect(summary.written).toBe(1);
+    expect(summary.invalid).toBe(2);
+    expect(summary.results[0].action).toBe("invalid");
+    expect(summary.results[0].error).toContain("reserved for synthetic");
+    expect(summary.results[1].action).toBe("invalid");
+    expect(await readPage(workspace, "skills/browser")).toBeNull();
+    expect(await readPage(workspace, "cli-commands/memory")).toBeNull();
+    expect(await readPage(workspace, "people/alice")).not.toBeNull();
+  });
+
+  test("missing source and unparseable origin_date produce warnings, not failures", async () => {
+    const summary = await ingestPages(workspace, [
+      { slug: "no-source", content: "---\nedges: []\n---\nNo provenance.\n" },
+      {
+        slug: "bad-date",
+        content:
+          "---\nsource: import:chatgpt\norigin_date: sometime last spring\n---\nBody.\n",
+      },
+    ]);
+
+    expect(summary.written).toBe(2);
+    expect(summary.invalid).toBe(0);
+    expect(summary.results[0].warnings.join(" ")).toContain("source");
+    expect(summary.results[1].warnings.join(" ")).toContain("origin_date");
+  });
+
+  test("frontmatter slug differing from the storage slug warns without blocking the write", async () => {
+    const summary = await ingestPages(workspace, [
+      {
+        slug: "people/alice",
+        content:
+          "---\nsource: import:chatgpt\norigin_date: 2025-03-14\nslug: people/alicia\n---\nBody.\n",
+      },
+      {
+        slug: "people/bob",
+        content:
+          "---\nsource: import:chatgpt\norigin_date: 2025-03-14\nslug: people/bob\n---\nBody.\n",
+      },
+    ]);
+
+    expect(summary.written).toBe(2);
+    expect(summary.invalid).toBe(0);
+    const mismatch = summary.results[0].warnings.join(" ");
+    expect(mismatch).toContain("people/alicia");
+    expect(mismatch).toContain("people/alice");
+    expect(mismatch).toContain("storage slug");
+    // A matching frontmatter slug stays silent.
+    expect(summary.results[1].warnings).toEqual([]);
+    // The page lands under the storage slug regardless of the warning.
+    expect(await listPages(workspace)).toEqual(["people/alice", "people/bob"]);
+  });
+
+  test("a pending reindex job of the same type suppresses its duplicate enqueue", async () => {
+    pendingJobTypes = new Set(["memory_v2_reembed"]);
+    await ingestPages(workspace, [
+      { slug: "people/alice", content: validPage("Alice likes hiking.") },
+    ]);
+    expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v3_maintain"]);
+  });
+
+  test("a page committed during lock acquisition is skipped, not overwritten", async () => {
+    // Simulated concurrent writer: the colliding page lands on disk after
+    // validation ran and right after the lock is acquired, so only an
+    // under-lock snapshot can see it.
+    onLockAcquired = () => {
+      const path = join(workspace, "memory", "concepts", "people", "alice.md");
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, validPage("Concurrent writer body."));
+    };
+
+    const summary = await ingestPages(workspace, [
+      { slug: "people/alice", content: validPage("Ingest body.") },
+    ]);
+
+    // The collision snapshot ran after lock acquisition.
+    expect(callTrace).toEqual(["tryAcquireLock", "listPages"]);
+    expect(summary.results[0].action).toBe("skipped_exists");
+    expect(summary.written).toBe(0);
+    expect(summary.skipped).toBe(1);
+    const preserved = await readPage(workspace, "people/alice");
+    expect(preserved?.body.trim()).toBe("Concurrent writer body.");
+    // Nothing written, so no reindex fan-out; the lock is released.
+    expect(enqueuedJobs).toEqual([]);
+    expect(existsSync(lockPath())).toBe(false);
+  });
+
+  test("dry-run takes its advisory snapshot without touching the lock", async () => {
+    await ingestPages(
+      workspace,
+      [{ slug: "people/alice", content: validPage("Alice likes hiking.") }],
+      { dryRun: true },
+    );
+    expect(callTrace).toEqual(["listPages"]);
+  });
+
+  test("a mid-batch write failure still enqueues reindex follow-ups for committed pages", async () => {
+    failWriteSlugs = new Set(["projects/garden"]);
+
+    let thrown: unknown;
+    try {
+      await ingestPages(workspace, [
+        { slug: "people/alice", content: validPage("Alice likes hiking.") },
+        {
+          slug: "projects/garden",
+          content: validPage("Garden redesign notes."),
+        },
+      ]);
+    } catch (err) {
+      thrown = err;
+    }
+
+    // The write error propagates to the caller.
+    expect(thrown).toBeInstanceOf(Error);
+    expect((thrown as Error).message).toContain(
+      "simulated write failure: projects/garden",
+    );
+    // The first page committed before the failure and still gets its
+    // reindex fan-out, once per job type.
+    expect(await listPages(workspace)).toEqual(["people/alice"]);
+    expect(enqueuedJobs.map((j) => j.type).sort()).toEqual([
+      "memory_v2_reembed",
+      "memory_v3_maintain",
+    ]);
+    // The lock is released despite the failure.
+    expect(existsSync(lockPath())).toBe(false);
+  });
+});

package/src/plugins/defaults/memory/substrate/__tests__/page-index.test.ts

@@ -48,8 +48,12 @@ mock.module("../page-store.js", () => ({
   },
 }));
 
-const { getPageIndex, invalidatePageIndex, partitionPageIndex } =
-  await import("../page-index.js");
+const {
+  getPageIndex,
+  invalidatePageIndex,
+  parseOriginDate,
+  partitionPageIndex,
+} = await import("../page-index.js");
 const { writePage } = await import("../page-store.js");
 const { invalidateEdgeIndex } = await import("../edge-index.js");
 
@@ -76,6 +80,7 @@ function makePage(
     summary?: string;
     body?: string;
     leaves?: string[];
+    originDate?: string;
   } = {},
 ): ConceptPage {
   return {
@@ -86,6 +91,9 @@ function makePage(
       ref_urls: [],
       ...(opts.summary !== undefined ? { summary: opts.summary } : {}),
       ...(opts.leaves !== undefined ? { leaves: opts.leaves } : {}),
+      ...(opts.originDate !== undefined
+        ? { origin_date: opts.originDate }
+        : {}),
     },
     body: opts.body ?? "",
   };
@@ -376,6 +384,79 @@ describe("getPageIndex", () => {
     );
   });
 
+  test("freshAt is the parsed origin_date; modifiedAt stays raw mtime", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("imported", { summary: "I", originDate: "2019-03-05" }),
+    );
+
+    const idx = await getPageIndex(workspaceDir);
+    const entry = idx.bySlug.get("imported")!;
+    expect(entry.freshAt).toBe(Date.parse("2019-03-05"));
+    // The file was written just now, so its raw mtime is far past the
+    // backdated origin: modifiedAt must not follow origin_date.
+    expect(entry.modifiedAt).toBeGreaterThan(Date.parse("2019-03-05"));
+  });
+
+  test("freshAt keeps a pre-epoch origin_date as its negative parsed epoch", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("archival", { summary: "A", originDate: "1969-07-20" }),
+    );
+
+    const idx = await getPageIndex(workspaceDir);
+    const entry = idx.bySlug.get("archival")!;
+    // 1969-07-20 parses to a negative epoch-ms value; the declared
+    // chronology wins over the current file mtime.
+    expect(entry.freshAt).toBe(Date.parse("1969-07-20"));
+    expect(entry.freshAt).toBeLessThan(0);
+    expect(entry.freshAt).not.toBe(entry.modifiedAt);
+  });
+
+  test("freshAt reads an offset-less ISO datetime as UTC", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("meeting", {
+        summary: "M",
+        originDate: "2019-06-10T14:23:00",
+      }),
+    );
+
+    const idx = await getPageIndex(workspaceDir);
+    const entry = idx.bySlug.get("meeting")!;
+    // Deterministic across host timezones: the offset-less datetime is
+    // normalized to UTC before parsing.
+    expect(entry.freshAt).toBe(Date.parse("2019-06-10T14:23:00Z"));
+  });
+
+  test("freshAt falls back to file mtime when origin_date is absent", async () => {
+    await writePage(workspaceDir, makePage("alice", { summary: "A" }));
+
+    const idx = await getPageIndex(workspaceDir);
+    const entry = idx.bySlug.get("alice")!;
+    expect(entry.freshAt).toBeGreaterThan(0);
+    expect(entry.freshAt).toBe(entry.modifiedAt);
+  });
+
+  test("freshAt falls back to file mtime when origin_date is unparseable", async () => {
+    await writePage(
+      workspaceDir,
+      makePage("garbled", { summary: "G", originDate: "not-a-date" }),
+    );
+
+    const idx = await getPageIndex(workspaceDir);
+    const entry = idx.bySlug.get("garbled")!;
+    expect(entry.freshAt).toBeGreaterThan(0);
+    expect(entry.freshAt).toBe(entry.modifiedAt);
+  });
+
+  test("synthetic skill entries carry freshAt null", async () => {
+    skillState.entries = [{ id: "browser", content: "Drive a browser." }];
+
+    const idx = await getPageIndex(workspaceDir);
+    expect(idx.bySlug.get("skills/browser")?.freshAt).toBeNull();
+  });
+
   test("collision dedupe leaves non-colliding pages and skills intact", async () => {
     await writePage(workspaceDir, makePage("alice", { summary: "Alice" }));
     await writePage(
@@ -397,6 +478,52 @@ describe("getPageIndex", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// parseOriginDate: the shared origin_date parser
+// ---------------------------------------------------------------------------
+
+describe("parseOriginDate", () => {
+  test("parses an ISO date to epoch ms", () => {
+    expect(parseOriginDate("2019-03-05")).toBe(Date.parse("2019-03-05"));
+  });
+
+  test("keeps a pre-epoch date as its negative parsed epoch", () => {
+    const parsed = parseOriginDate("1969-07-20");
+    expect(parsed).toBe(Date.parse("1969-07-20"));
+    expect(parsed).toBeLessThan(0);
+  });
+
+  test("reads an offset-less ISO datetime as UTC", () => {
+    expect(parseOriginDate("2019-06-10T14:23:00")).toBe(
+      Date.parse("2019-06-10T14:23:00Z"),
+    );
+  });
+
+  test("preserves an explicit offset", () => {
+    expect(parseOriginDate("2019-06-10T14:23:00+02:00")).toBe(
+      Date.parse("2019-06-10T12:23:00Z"),
+    );
+  });
+
+  test("returns null for an unparseable value", () => {
+    expect(parseOriginDate("sometime last spring")).toBeNull();
+    expect(parseOriginDate("")).toBeNull();
+  });
+
+  test("rejects non-ISO shapes even when Date.parse would accept them", () => {
+    expect(parseOriginDate("03/04/2025")).toBeNull();
+    expect(parseOriginDate("Apr 3 2025")).toBeNull();
+    expect(parseOriginDate("2025-4-3")).toBeNull();
+  });
+
+  test("rejects impossible calendar dates instead of normalizing them", () => {
+    expect(parseOriginDate("2025-02-30")).toBeNull();
+    expect(parseOriginDate("2025-04-31")).toBeNull();
+    expect(parseOriginDate("2025-02-30T10:00:00Z")).toBeNull();
+    expect(parseOriginDate("2024-02-29")).toBe(Date.parse("2024-02-29"));
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Render
 // ---------------------------------------------------------------------------

package/src/plugins/defaults/memory/substrate/__tests__/page-store.test.ts

@@ -241,6 +241,37 @@ describe("writePage + readPage round-trip", () => {
     expect(read!.frontmatter.status).toBe("cc-draft");
   });
 
+  test("round-trips the provenance fields (source, origin_date)", async () => {
+    // Imported/backfilled pages carry `source: import:<provider>` and an
+    // `origin_date:` for original chronology. Both are declared (not
+    // passthrough) so they parse with a real type and survive the
+    // renderPageContent write -> readPage round-trip.
+    const page = makePage({
+      slug: "imported-page",
+      frontmatter: {
+        edges: [],
+        ref_files: [],
+        ref_urls: [],
+        source: "import:chatgpt",
+        origin_date: "2023-04-01",
+      },
+    });
+    await writePage(workspaceDir, page);
+
+    const read = await readPage(workspaceDir, "imported-page");
+    expect(read).not.toBeNull();
+    expect(read!.frontmatter.source).toBe("import:chatgpt");
+    expect(read!.frontmatter.origin_date).toBe("2023-04-01");
+
+    // The rendered file carries both keys in its frontmatter block.
+    const raw = readFileSync(
+      join(workspaceDir, "memory", "concepts", "imported-page.md"),
+      "utf-8",
+    );
+    expect(raw).toMatch(/source: "?import:chatgpt"?/);
+    expect(raw).toMatch(/origin_date: "?2023-04-01"?/);
+  });
+
   test("renders frontmatter at the top with --- delimiters", async () => {
     const page = makePage();
     await writePage(workspaceDir, page);