@vellumai/assistant 0.7.3 → 0.8.1

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -1,17 +1,16 @@
 /**
  * Tests for `assistant/src/memory/v2/consolidation-job.ts`.
  *
- * Coverage matrix (from PR 20 acceptance criteria):
- *   - Flag off → no provider/wake calls; returns flag_off.
- *   - Flag on, empty buffer → no wake call; returns empty_buffer.
- *   - Flag on, non-empty buffer → bootstrap conversation, wake invoked with
- *     the cutoff-templated prompt, follow-up jobs enqueued.
- *   - Lock file already present → second call returns locked; first call's
- *     in-flight semantics preserved by leaving the lock in place.
- *   - Wake returns invoked: false → orphan conversation cleaned up; no
- *     follow-up jobs enqueued.
- *   - Wake throws → orphan conversation cleaned up; lock released; handler
- *     does NOT propagate the error (treated like any other wake failure).
+ * Coverage matrix:
+ *   - Flag off → no runner call; returns disabled.
+ *   - Flag on, empty buffer → no runner call; returns empty_buffer.
+ *   - Flag on, non-empty buffer → runner invoked with the cutoff-templated
+ *     prompt and `suppressFailureNotifications: true`; follow-up jobs
+ *     enqueued on success.
+ *   - Lock file already present → second call returns locked.
+ *   - Runner returns ok=false → run_failed surfaced; NO follow-up jobs;
+ *     `emitNotificationSignal` was NOT called as a result of the failure
+ *     (suppression is honored end-to-end).
  *
  * Tests use temp workspaces (mkdtemp) and never touch `~/.vellum/`. Sample
  * content uses generic placeholders (Alice).
@@ -27,7 +26,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -42,31 +40,49 @@ mock.module("../../../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
-// ── bootstrapConversation mock ──────────────────────────────────────
-let bootstrapCalls = 0;
-let bootstrapLastArgs: Record<string, unknown> | null = null;
-
-mock.module("../../conversation-bootstrap.js", () => ({
-  bootstrapConversation: (opts: Record<string, unknown>) => {
-    bootstrapCalls += 1;
-    bootstrapLastArgs = opts;
-    return { id: `conv-${bootstrapCalls}` };
+// ── runBackgroundJob mock ───────────────────────────────────────────
+//
+// The consolidation handler delegates the bootstrap + processMessage +
+// timeout + classification + suppress-aware emit to runBackgroundJob.
+// We stub it here and assert (a) the runner is called with
+// `suppressFailureNotifications: true`, and (b) the prompt + callSite
+// + trustContext + origin match what the consolidation surface expects.
+let runnerCalls = 0;
+let runnerLastArgs: Record<string, unknown> | null = null;
+let runnerImpl: () => Promise<{
+  conversationId: string;
+  ok: boolean;
+  error?: Error;
+  errorKind?: string;
+}> = async () => ({ conversationId: "conv-1", ok: true });
+
+mock.module("../../../runtime/background-job-runner.js", () => ({
+  runBackgroundJob: async (opts: Record<string, unknown>) => {
+    runnerCalls += 1;
+    runnerLastArgs = opts;
+    return runnerImpl();
   },
 }));
 
-// ── deleteConversation mock (orphan cleanup path) ───────────────────
-let deleteCalls = 0;
-const deletedIds: string[] = [];
-let deleteShouldThrow = false;
-
-mock.module("../../conversation-crud.js", () => ({
-  deleteConversation: (id: string) => {
-    deleteCalls += 1;
-    deletedIds.push(id);
-    if (deleteShouldThrow) {
-      throw new Error("simulated delete failure");
-    }
-    return { segmentIds: [], deletedSummaryIds: [] };
+// ── emitNotificationSignal spy ──────────────────────────────────────
+//
+// The runner is stubbed above, so the real `emit-signal` module never
+// runs in these tests. We mock it as a defensive belt-and-suspenders
+// assertion: even if the runner stub were swapped out for the real
+// implementation, this counter would catch any path that ends up
+// emitting a signal as a result of consolidation failure.
+const emitCalls: Array<Record<string, unknown>> = [];
+
+mock.module("../../../notifications/emit-signal.js", () => ({
+  emitNotificationSignal: async (params: Record<string, unknown>) => {
+    emitCalls.push(params);
+    return {
+      signalId: "sig-1",
+      deduplicated: false,
+      dispatched: true,
+      reason: "ok",
+      deliveryResults: [],
+    };
   },
 }));
 
@@ -88,28 +104,6 @@ mock.module("../../jobs-store.js", () => ({
   },
 }));
 
-// ── wakeAgentForOpportunity mock ────────────────────────────────────
-let wakeCalls = 0;
-let wakeLastArgs: Record<string, unknown> | null = null;
-let wakeShouldThrow = false;
-let wakeInvoked = true;
-let wakeReason: string | undefined;
-
-mock.module("../../../runtime/agent-wake.js", () => ({
-  wakeAgentForOpportunity: async (opts: Record<string, unknown>) => {
-    wakeCalls += 1;
-    wakeLastArgs = opts;
-    if (wakeShouldThrow) {
-      throw new Error("simulated wake failure");
-    }
-    return {
-      invoked: wakeInvoked,
-      producedToolCalls: false,
-      ...(wakeReason ? { reason: wakeReason } : {}),
-    };
-  },
-}));
-
 // ── Workspace pin ───────────────────────────────────────────────────
 let tmpWorkspace: string;
 let previousWorkspaceEnv: string | undefined;
@@ -129,19 +123,18 @@ afterAll(() => {
   rmSync(tmpWorkspace, { recursive: true, force: true });
 });
 
-const { _setOverridesForTesting } =
-  await import("../../../config/assistant-feature-flags.js");
 const { memoryV2ConsolidateJob } = await import("../consolidation-job.js");
 const { CUTOFF_PLACEHOLDER, CONSOLIDATION_PROMPT } =
   await import("../prompts/consolidation.js");
 
-// `isAssistantFeatureFlagEnabled` ignores the `config` argument it receives
-// (resolution is purely from the overrides + registry caches), and the
-// resolver only reads `config.memory.v2.consolidation_prompt_path` — so a
-// minimal stand-in covers both call sites without materializing the full
-// default config.
+// The resolver only reads `config.memory.v2.enabled` and
+// `config.memory.v2.consolidation_prompt_path`, so a minimal stand-in
+// covers both call sites without materializing the full default config.
 const CONFIG = {
-  memory: { v2: { consolidation_prompt_path: null } },
+  memory: { v2: { enabled: true, consolidation_prompt_path: null } },
+} as Parameters<typeof memoryV2ConsolidateJob>[1];
+const CONFIG_DISABLED = {
+  memory: { v2: { enabled: false, consolidation_prompt_path: null } },
 } as Parameters<typeof memoryV2ConsolidateJob>[1];
 
 function makeJob(): Parameters<typeof memoryV2ConsolidateJob>[0] {
@@ -173,56 +166,39 @@ beforeEach(() => {
   mkdirSync(join(memoryDir(), "concepts"), { recursive: true });
   mkdirSync(join(memoryDir(), "archive"), { recursive: true });
 
-  bootstrapCalls = 0;
-  bootstrapLastArgs = null;
-  deleteCalls = 0;
-  deletedIds.length = 0;
-  deleteShouldThrow = false;
+  runnerCalls = 0;
+  runnerLastArgs = null;
+  runnerImpl = async () => ({ conversationId: "conv-1", ok: true });
+  emitCalls.length = 0;
   enqueuedJobs.length = 0;
   nextJobIdCounter = 0;
-  wakeCalls = 0;
-  wakeLastArgs = null;
-  wakeShouldThrow = false;
-  wakeInvoked = true;
-  wakeReason = undefined;
-});
-
-afterEach(() => {
-  _setOverridesForTesting({});
 });
 
 // ---------------------------------------------------------------------------
 
-describe("memoryV2ConsolidateJob — flag off", () => {
-  test("returns flag_off without invoking the wake when flag is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
+describe("memoryV2ConsolidateJob — v2 disabled", () => {
+  test("returns disabled without invoking the runner when memory.v2.enabled is false", async () => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");
 
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG_DISABLED);
 
-    expect(result).toEqual({ kind: "flag_off" });
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(result).toEqual({ kind: "disabled" });
+    expect(runnerCalls).toBe(0);
     expect(enqueuedJobs).toHaveLength(0);
-    // Lock must NOT linger on the flag-off path — the handler bailed before
+    // Lock must NOT linger on the disabled path — the handler bailed before
     // the lock was acquired.
     expect(existsSync(lockPath())).toBe(false);
   });
 });
 
-describe("memoryV2ConsolidateJob — flag on, empty buffer", () => {
-  beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
-  });
-
+describe("memoryV2ConsolidateJob — empty buffer", () => {
   test("returns empty_buffer when buffer.md is missing", async () => {
     expect(existsSync(bufferPath())).toBe(false);
 
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result).toEqual({ kind: "empty_buffer" });
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runnerCalls).toBe(0);
     expect(enqueuedJobs).toHaveLength(0);
   });
 
@@ -232,8 +208,7 @@ describe("memoryV2ConsolidateJob — flag on, empty buffer", () => {
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result).toEqual({ kind: "empty_buffer" });
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runnerCalls).toBe(0);
     expect(enqueuedJobs).toHaveLength(0);
   });
 
@@ -244,9 +219,8 @@ describe("memoryV2ConsolidateJob — flag on, empty buffer", () => {
   });
 });
 
-describe("memoryV2ConsolidateJob — flag on, non-empty buffer", () => {
+describe("memoryV2ConsolidateJob — non-empty buffer", () => {
   beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     writeFileSync(
       bufferPath(),
       "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
@@ -254,32 +228,37 @@ describe("memoryV2ConsolidateJob — flag on, non-empty buffer", () => {
     );
   });
 
-  test("bootstraps a background conversation and wakes the assistant with a templated prompt", async () => {
+  test("invokes runBackgroundJob with the cutoff-templated prompt and suppressFailureNotifications: true", async () => {
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    expect(bootstrapCalls).toBe(1);
-    expect(bootstrapLastArgs).toEqual({
-      conversationType: "background",
-      source: "memory_v2_consolidation",
-      origin: "memory_consolidation",
-      systemHint: "Running memory consolidation",
-      groupId: "system:background",
+    expect(runnerCalls).toBe(1);
+    expect(runnerLastArgs).not.toBeNull();
+    expect(runnerLastArgs?.jobName).toBe("memory.consolidate");
+    expect(runnerLastArgs?.source).toBe("memory_v2_consolidation");
+    expect(runnerLastArgs?.callSite).toBe("mainAgent");
+    expect(runnerLastArgs?.origin).toBe("memory_consolidation");
+    // The whole point of this PR: opt out of activity.failed notifications
+    // because consolidation runs on tight intervals and transient failures
+    // would spam the home feed.
+    expect(runnerLastArgs?.suppressFailureNotifications).toBe(true);
+    expect(runnerLastArgs?.trustContext).toEqual({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
     });
-
-    expect(wakeCalls).toBe(1);
-    expect(wakeLastArgs?.conversationId).toBe("conv-1");
-    expect(wakeLastArgs?.source).toBe("memory_v2_consolidation");
-
-    // The hint must contain the prompt body with the cutoff timestamp
-    // substituted in. Asserting the placeholder is GONE catches a regression
-    // where `replaceAll` is dropped and the model receives `{{CUTOFF}}`.
-    const hint = wakeLastArgs?.hint as string;
-    expect(hint).toContain("memory consolidation");
-    expect(hint).not.toContain(CUTOFF_PLACEHOLDER);
-    // Cutoff is an ISO-8601 timestamp — check the year prefix matches the
-    // current year so we know the substitution actually happened.
-    expect(hint).toContain(`${new Date().getFullYear()}`);
+    expect(typeof runnerLastArgs?.timeoutMs).toBe("number");
+    expect((runnerLastArgs?.timeoutMs as number) > 0).toBe(true);
+
+    // The prompt must contain the rendered consolidation body with the
+    // cutoff substituted in. Asserting the placeholder is GONE catches a
+    // regression where `replaceAll` is dropped and the model receives
+    // `{{CUTOFF}}` literally.
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).toContain("memory consolidation");
+    expect(prompt).not.toContain(CUTOFF_PLACEHOLDER);
+    // Cutoff is a buffer-entry-format timestamp (`Mon D, h:mm AM/PM`) so it
+    // compares like-with-like against `buffer.md` lines at minute precision.
+    expect(prompt).toMatch(/\b[A-Z][a-z]{2} \d{1,2}, \d{1,2}:\d{2} (AM|PM)\b/);
   });
 
   test("honors memory.v2.consolidation_prompt_path override when set", async () => {
@@ -288,16 +267,20 @@ describe("memoryV2ConsolidateJob — flag on, non-empty buffer", () => {
       "CUSTOM CONSOLIDATION at {{CUTOFF}}\n",
     );
     const overrideConfig = {
-      memory: { v2: { consolidation_prompt_path: "custom-prompt.md" } },
+      memory: {
+        v2: { enabled: true, consolidation_prompt_path: "custom-prompt.md" },
+      },
     } as Parameters<typeof memoryV2ConsolidateJob>[1];
 
     const result = await memoryV2ConsolidateJob(makeJob(), overrideConfig);
 
     expect(result.kind).toBe("invoked");
-    const hint = wakeLastArgs?.hint as string;
-    expect(hint).toMatch(/^CUSTOM CONSOLIDATION at \d{4}-/);
-    expect(hint).not.toContain("You are running memory consolidation");
-    expect(hint).not.toContain(CUTOFF_PLACEHOLDER);
+    const prompt = runnerLastArgs?.prompt as string;
+    expect(prompt).toMatch(
+      /^CUSTOM CONSOLIDATION at [A-Z][a-z]{2} \d{1,2}, \d{1,2}:\d{2} (AM|PM)$/m,
+    );
+    expect(prompt).not.toContain("You are running memory consolidation");
+    expect(prompt).not.toContain(CUTOFF_PLACEHOLDER);
   });
 
   test("enqueues the memory_v2_reembed follow-up job on success", async () => {
@@ -321,54 +304,51 @@ describe("memoryV2ConsolidateJob — flag on, non-empty buffer", () => {
     expect(existsSync(lockPath())).toBe(false);
   });
 
-  test("returns wake_failed and cleans up the orphan conversation when wake returns invoked: false", async () => {
-    wakeInvoked = false;
-    wakeReason = "no_resolver";
+  test("returns run_failed and skips follow-ups when the runner reports failure", async () => {
+    runnerImpl = async () => ({
+      conversationId: "conv-1",
+      ok: false,
+      error: new Error("simulated runner failure"),
+      errorKind: "exception",
+    });
 
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
-    expect(result.kind).toBe("wake_failed");
-    if (result.kind === "wake_failed") {
-      expect(result.reason).toBe("no_resolver");
+    expect(result.kind).toBe("run_failed");
+    if (result.kind === "run_failed") {
+      expect(result.reason).toBe("simulated runner failure");
     }
-    expect(deleteCalls).toBe(1);
-    expect(deletedIds).toEqual(["conv-1"]);
-    // Critical: do NOT enqueue follow-ups when the wake didn't run — there's
-    // nothing for them to operate on.
+    // No follow-ups: the agent's writes may be partial and re-embedding
+    // partial state would be misleading.
     expect(enqueuedJobs).toHaveLength(0);
-  });
-
-  test("returns wake_failed without throwing when wake itself rejects", async () => {
-    wakeShouldThrow = true;
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("wake_failed");
-    if (result.kind === "wake_failed") {
-      expect(result.reason).toBe("simulated wake failure");
-    }
-    // Lock must still be released on the throw path.
+    // Lock must still be released on the failure path so the next
+    // scheduled consolidation can re-attempt.
     expect(existsSync(lockPath())).toBe(false);
-    expect(deleteCalls).toBe(1);
-    expect(enqueuedJobs).toHaveLength(0);
   });
 
-  test("does not propagate when deleteConversation throws on the cleanup path", async () => {
-    wakeInvoked = false;
-    deleteShouldThrow = true;
+  test("does NOT emit a notification signal when the runner fails (suppression honored)", async () => {
+    // This is the user-visible payoff of `suppressFailureNotifications: true`:
+    // even when the runner stub reports a failure, the consolidation
+    // handler must not produce any notification side-effect. The runner
+    // itself owns the suppression behavior; this test guards the contract
+    // from the consolidation surface — if a future change ever bypasses
+    // the runner and emits its own signal on the failure path, this assert
+    // will catch it.
+    runnerImpl = async () => ({
+      conversationId: "conv-1",
+      ok: false,
+      error: new Error("network blip"),
+      errorKind: "model_provider",
+    });
 
-    await expect(
-      memoryV2ConsolidateJob(makeJob(), CONFIG),
-    ).resolves.toMatchObject({ kind: "wake_failed" });
+    await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
-    expect(deleteCalls).toBe(1);
-    expect(existsSync(lockPath())).toBe(false);
+    expect(emitCalls).toHaveLength(0);
   });
 });
 
 describe("memoryV2ConsolidateJob — concurrent invocations", () => {
   beforeEach(() => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");
   });
 
@@ -385,8 +365,7 @@ describe("memoryV2ConsolidateJob — concurrent invocations", () => {
     if (result.kind === "locked") {
       expect(result.holder).toContain(`${process.pid}`);
     }
-    expect(bootstrapCalls).toBe(0);
-    expect(wakeCalls).toBe(0);
+    expect(runnerCalls).toBe(0);
     expect(enqueuedJobs).toHaveLength(0);
     // The live holder's lock must NOT be removed by a contender.
     expect(existsSync(lockPath())).toBe(true);
@@ -403,8 +382,7 @@ describe("memoryV2ConsolidateJob — concurrent invocations", () => {
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runnerCalls).toBe(1);
     // Lock is released in the finally block after a successful run.
     expect(existsSync(lockPath())).toBe(false);
   });
@@ -420,8 +398,7 @@ describe("memoryV2ConsolidateJob — concurrent invocations", () => {
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
-    expect(bootstrapCalls).toBe(1);
-    expect(wakeCalls).toBe(1);
+    expect(runnerCalls).toBe(1);
     expect(existsSync(lockPath())).toBe(false);
   });
 });

package/src/memory/v2/__tests__/edge-index.test.ts

@@ -36,7 +36,7 @@ afterEach(() => {
 function makePage(slug: string, edges: string[] = [], body = ""): ConceptPage {
   return {
     slug,
-    frontmatter: { edges, ref_files: [] },
+    frontmatter: { edges, ref_files: [], ref_urls: [] },
     body,
   };
 }

package/src/memory/v2/__tests__/frontmatter-sweep.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Tests for `assistant/src/memory/v2/frontmatter-sweep.ts`.
+ *
+ * Coverage:
+ *   - Empty workspace → no warns, no throw.
+ *   - One bad page (unknown frontmatter key) → exactly one warn carrying
+ *     `errCode: "unrecognized_keys"` and the offending slug.
+ *   - Two bad + one good page → two warns; good page produces nothing.
+ *   - Malformed YAML → a warn surfaces; the sweep does not crash.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const warnCalls: Array<{ data: Record<string, unknown>; msg: string }> = [];
+const recordingLogger = {
+  warn: (data: Record<string, unknown>, msg: string) => {
+    warnCalls.push({ data, msg });
+  },
+  info: () => {},
+  debug: () => {},
+  error: () => {},
+  trace: () => {},
+  fatal: () => {},
+  child: () => recordingLogger,
+};
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => recordingLogger,
+}));
+
+const { sweepConceptPageFrontmatter } = await import("../frontmatter-sweep.js");
+
+function makeWorkspace(pages: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), "frontmatter-sweep-"));
+  const conceptsDir = join(dir, "memory", "concepts");
+  if (Object.keys(pages).length > 0) {
+    mkdirSync(conceptsDir, { recursive: true });
+    for (const [slug, content] of Object.entries(pages)) {
+      writeFileSync(join(conceptsDir, `${slug}.md`), content, "utf-8");
+    }
+  }
+  return dir;
+}
+
+const goodPage = `---\nedges: []\nref_files: []\n---\nbody\n`;
+const badPage = `---\nedges: []\nref_files: []\nbogus_field: 1\n---\nbody\n`;
+
+describe("sweepConceptPageFrontmatter", () => {
+  beforeEach(() => {
+    warnCalls.length = 0;
+  });
+  afterEach(() => {
+    warnCalls.length = 0;
+  });
+
+  test("empty workspace: no warns, no throw", async () => {
+    const dir = makeWorkspace({});
+    try {
+      await sweepConceptPageFrontmatter(dir);
+      expect(warnCalls).toHaveLength(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("one bad page emits exactly one unrecognized_keys warn", async () => {
+    const dir = makeWorkspace({ "bad-one": badPage });
+    try {
+      await sweepConceptPageFrontmatter(dir);
+      expect(warnCalls).toHaveLength(1);
+      expect(warnCalls[0].data.slug).toBe("bad-one");
+      expect(warnCalls[0].data.errCode).toBe("unrecognized_keys");
+      expect(warnCalls[0].data.errKeys).toEqual(["bogus_field"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("two bad and one good page: one warn per bad slug, none for the good", async () => {
+    const dir = makeWorkspace({
+      good: goodPage,
+      "bad-a": badPage,
+      "bad-b": badPage,
+    });
+    try {
+      await sweepConceptPageFrontmatter(dir);
+      const slugs = warnCalls.map((c) => c.data.slug).sort();
+      expect(slugs).toEqual(["bad-a", "bad-b"]);
+      for (const call of warnCalls) {
+        expect(call.data.errCode).toBe("unrecognized_keys");
+      }
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("malformed YAML: warn surfaces, sweep does not throw", async () => {
+    const dir = makeWorkspace({
+      mangled: `---\nedges: [unterminated\n---\nbody\n`,
+    });
+    try {
+      await sweepConceptPageFrontmatter(dir);
+      expect(warnCalls.length).toBeGreaterThanOrEqual(1);
+      expect(warnCalls.some((c) => c.data.slug === "mangled")).toBe(true);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});