@vellumai/assistant 0.6.6 → 0.7.1

package/src/memory/v2/__tests__/page-store.test.ts

@@ -0,0 +1,517 @@
+/**
+ * Tests for `assistant/src/memory/v2/page-store.ts`.
+ *
+ * Coverage matrix:
+ *   - slugify: lowercase / kebab-case / ascii / 80-char cap / empty fallback.
+ *   - validateSlug: accept set, reject set (path-traversal, malformed shapes).
+ *   - readPage / writePage round-trip: frontmatter survives, body preserved.
+ *   - readPage on missing file: returns null.
+ *   - writePage atomicity: a fault between temp-write and rename leaves the
+ *     prior file intact (or the new one) — never a half-written page.
+ *   - writePage creates parent directories for nested slugs.
+ *   - listPages: walks subdirectories, returns nested slugs in `/`-form,
+ *     excludes hidden dirs / non-.md / temp files, missing dir → [].
+ *   - deletePage / pageExists: nested-slug round-trip, idempotent on missing.
+ *
+ * Tests use temp workspaces under `os.tmpdir()` per the cross-cutting safety
+ * rule in the v2 plan; they never touch `~/.vellum/`.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  deletePage,
+  listPages,
+  pageExists,
+  readPage,
+  slugify,
+  validateSlug,
+  writePage,
+} from "../page-store.js";
+import type { ConceptPage } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-page-store-test-"));
+  // Mirror the workspace migration so readPage / writePage have a target dir.
+  mkdirSync(join(workspaceDir, "memory", "concepts"), { recursive: true });
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function makePage(overrides: Partial<ConceptPage> = {}): ConceptPage {
+  return {
+    slug: "alice-preferences",
+    frontmatter: { edges: ["bob-handoff"], ref_files: [] },
+    body: "Alice prefers VS Code over Vim.\nShe ships at end of day.\n",
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// slugify
+// ---------------------------------------------------------------------------
+
+describe("slugify", () => {
+  test("lowercases ASCII letters", () => {
+    expect(slugify("AliceBob")).toBe("alicebob");
+  });
+
+  test("converts spaces and punctuation to single hyphens", () => {
+    expect(slugify("Alice's Preferred IDE!")).toBe("alice-s-preferred-ide");
+  });
+
+  test("collapses runs of separators to one hyphen", () => {
+    expect(slugify("foo   ___ bar")).toBe("foo-bar");
+  });
+
+  test("trims leading and trailing hyphens", () => {
+    expect(slugify("---hello world---")).toBe("hello-world");
+  });
+
+  test("strips non-ASCII characters via NFKD normalization", () => {
+    // Non-ASCII reduces to hyphens; we want a stable ascii-only slug.
+    expect(slugify("café résumé")).toMatch(/^[a-z0-9-]+$/);
+  });
+
+  test("collapses '/' to hyphen — slugify produces a single segment", () => {
+    // Path-shaped slugs are constructed by writing to nested paths, not by
+    // passing slash-bearing input through slugify.
+    expect(slugify("People/Alice")).toBe("people-alice");
+  });
+
+  test("caps slug length at 80 chars and re-trims trailing hyphen", () => {
+    const long = "a".repeat(120);
+    const slug = slugify(long);
+    expect(slug.length).toBe(80);
+    expect(slug.endsWith("-")).toBe(false);
+  });
+
+  test("falls back to a unique placeholder for empty inputs", () => {
+    const a = slugify("");
+    const b = slugify("!!!");
+    const c = slugify("###");
+    expect(a).toMatch(/^concept-[a-f0-9]{8}$/);
+    expect(b).toMatch(/^concept-[a-f0-9]{8}$/);
+    // Each call generates a fresh UUID, so distinct empty inputs do not collide.
+    expect(a).not.toBe(b);
+    expect(b).not.toBe(c);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// validateSlug
+// ---------------------------------------------------------------------------
+
+describe("validateSlug", () => {
+  test.each([
+    ["alice"],
+    ["a"],
+    ["alice-preferences"],
+    ["people/alice"],
+    ["procs/git-flow"],
+    ["arcs/2025-04-cutover"],
+    ["a/b/c/d/e"],
+    ["people/colleagues/alice"],
+  ])("accepts %p", (slug) => {
+    expect(() => validateSlug(slug)).not.toThrow();
+  });
+
+  test.each([
+    ["empty string", ""],
+    ["leading slash", "/alice"],
+    ["trailing slash", "alice/"],
+    ["double slash", "people//alice"],
+    ["dot-dot segment", "people/../alice"],
+    ["pure dot-dot", ".."],
+    ["leading dot segment", ".hidden/alice"],
+    ["backslash", "people\\alice"],
+    ["null byte", "alice\0evil"],
+    ["whitespace", "alice bob"],
+    ["uppercase", "Alice"],
+    ["non-ascii", "café"],
+    ["leading hyphen", "-alice"],
+    ["non-alphanumeric", "alice!"],
+  ])("rejects %s (%p)", (_label, slug) => {
+    expect(() => validateSlug(slug)).toThrow(/Invalid concept-page slug/);
+  });
+
+  test("rejects slugs longer than 200 chars", () => {
+    expect(() => validateSlug("a".repeat(201))).toThrow(
+      /Invalid concept-page slug/,
+    );
+  });
+
+  test("rejects segments longer than 80 chars even if total is under 200", () => {
+    expect(() => validateSlug("a".repeat(81))).toThrow(
+      /Invalid concept-page slug/,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// readPage / writePage round-trip
+// ---------------------------------------------------------------------------
+
+describe("writePage + readPage round-trip", () => {
+  test("round-trips frontmatter and body verbatim", async () => {
+    const page = makePage();
+    await writePage(workspaceDir, page);
+
+    const read = await readPage(workspaceDir, page.slug);
+    expect(read).not.toBeNull();
+    expect(read!.slug).toBe(page.slug);
+    expect(read!.frontmatter.edges).toEqual(page.frontmatter.edges);
+    expect(read!.frontmatter.ref_files).toEqual(page.frontmatter.ref_files);
+    expect(read!.body).toBe(page.body);
+  });
+
+  test("renders frontmatter at the top with --- delimiters", async () => {
+    const page = makePage();
+    await writePage(workspaceDir, page);
+
+    const raw = readFileSync(
+      join(workspaceDir, "memory", "concepts", `${page.slug}.md`),
+      "utf-8",
+    );
+    expect(raw.startsWith("---\n")).toBe(true);
+    // Body follows the closing delimiter exactly once.
+    expect(raw.split("---").length).toBeGreaterThanOrEqual(3);
+    expect(raw).toContain("Alice prefers VS Code");
+  });
+
+  test("preserves an empty body", async () => {
+    const page = makePage({ body: "" });
+    await writePage(workspaceDir, page);
+
+    const read = await readPage(workspaceDir, page.slug);
+    expect(read!.body).toBe("");
+  });
+
+  test("preserves multiline body with embedded YAML-looking lines", async () => {
+    const tricky = "key: value\n---\nnot-frontmatter\n";
+    const page = makePage({ slug: "tricky", body: tricky });
+    await writePage(workspaceDir, page);
+
+    const read = await readPage(workspaceDir, page.slug);
+    expect(read!.body).toBe(tricky);
+  });
+
+  test("readPage returns null for a slug that does not exist", async () => {
+    const result = await readPage(workspaceDir, "nonexistent-slug");
+    expect(result).toBeNull();
+  });
+
+  test("readPage parses a hand-written page with no frontmatter as empty frontmatter + full body", async () => {
+    const slug = "no-frontmatter";
+    const body = "Just some prose, no YAML.\n";
+    writeFileSync(
+      join(workspaceDir, "memory", "concepts", `${slug}.md`),
+      body,
+      "utf-8",
+    );
+
+    const read = await readPage(workspaceDir, slug);
+    expect(read).not.toBeNull();
+    expect(read!.frontmatter.edges).toEqual([]);
+    expect(read!.frontmatter.ref_files).toEqual([]);
+    expect(read!.body).toBe(body);
+  });
+
+  test("writePage overwrites an existing page", async () => {
+    const page1 = makePage({ body: "first version\n" });
+    await writePage(workspaceDir, page1);
+
+    const page2 = makePage({ body: "second version\n" });
+    await writePage(workspaceDir, page2);
+
+    const read = await readPage(workspaceDir, page1.slug);
+    expect(read!.body).toBe("second version\n");
+  });
+
+  test("writePage creates parent directories for nested slugs", async () => {
+    const page = makePage({ slug: "people/alice" });
+    await writePage(workspaceDir, page);
+
+    const filePath = join(
+      workspaceDir,
+      "memory",
+      "concepts",
+      "people",
+      "alice.md",
+    );
+    expect(existsSync(filePath)).toBe(true);
+
+    const read = await readPage(workspaceDir, "people/alice");
+    expect(read!.slug).toBe("people/alice");
+    expect(read!.body).toBe(page.body);
+  });
+
+  test("writePage round-trips deeply nested slugs", async () => {
+    const page = makePage({ slug: "people/colleagues/alice" });
+    await writePage(workspaceDir, page);
+
+    const read = await readPage(workspaceDir, "people/colleagues/alice");
+    expect(read!.slug).toBe("people/colleagues/alice");
+    expect(read!.frontmatter.edges).toEqual(page.frontmatter.edges);
+    expect(read!.body).toBe(page.body);
+  });
+
+  test("writePage rejects malicious slugs and writes nothing at the escape target", async () => {
+    await expect(
+      writePage(workspaceDir, makePage({ slug: "../escape" })),
+    ).rejects.toThrow(/Invalid concept-page slug/);
+
+    // `../escape` would resolve to `<workspace>/memory/escape.md`. Confirm
+    // the validation throw fired before any I/O — no file at that target.
+    expect(existsSync(join(workspaceDir, "memory", "escape.md"))).toBe(false);
+  });
+
+  test("readPage rejects malicious slugs", async () => {
+    await expect(readPage(workspaceDir, "../escape")).rejects.toThrow(
+      /Invalid concept-page slug/,
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Atomic write — fault injection
+// ---------------------------------------------------------------------------
+
+describe("writePage atomicity", () => {
+  test("write that fails partway leaves prior file intact and no orphan tmp", async () => {
+    // Seed the page with a known prior version.
+    const original = makePage({ body: "original body\n" });
+    await writePage(workspaceDir, original);
+    const originalRaw = readFileSync(
+      join(workspaceDir, "memory", "concepts", `${original.slug}.md`),
+      "utf-8",
+    );
+
+    // Inject a fault: replace the destination with a directory of the same
+    // name so `rename` cannot overwrite it (POSIX rejects renaming a regular
+    // file onto a non-empty directory). This forces writePage's temp-then-
+    // rename path to fail at the rename step — exactly the window where a
+    // real process crash would leave a stranded `.tmp.*` file behind. The
+    // assertions below verify (a) the prior page is untouched and (b) the
+    // catch block cleaned up the temp file before re-throwing.
+    const targetPath = join(
+      workspaceDir,
+      "memory",
+      "concepts",
+      `${original.slug}.md`,
+    );
+    rmSync(targetPath);
+    mkdirSync(targetPath);
+    writeFileSync(join(targetPath, "blocker"), "x", "utf-8");
+
+    await expect(
+      writePage(workspaceDir, makePage({ body: "interrupted body\n" })),
+    ).rejects.toThrow();
+
+    // Restore the directory shape so cleanup helpers don't trip.
+    rmSync(targetPath, { recursive: true, force: true });
+    writeFileSync(targetPath, originalRaw, "utf-8");
+
+    // Prior content is recoverable from what we just rewrote — i.e. the failed
+    // writePage never replaced it.
+    expect(readFileSync(targetPath, "utf-8")).toBe(originalRaw);
+
+    // No orphan .tmp.* files in concepts/ (cleanup ran in the catch block).
+    const remaining = readdirSync(join(workspaceDir, "memory", "concepts"));
+    const orphanTmps = remaining.filter((name) => name.includes(".tmp."));
+    expect(orphanTmps).toEqual([]);
+  });
+
+  test("nested-slug write that fails leaves no orphan tmp in nested folder", async () => {
+    // Seed a nested page so the parent dir exists.
+    const original = makePage({
+      slug: "people/alice",
+      body: "original body\n",
+    });
+    await writePage(workspaceDir, original);
+
+    const targetPath = join(
+      workspaceDir,
+      "memory",
+      "concepts",
+      "people",
+      "alice.md",
+    );
+    rmSync(targetPath);
+    mkdirSync(targetPath);
+    writeFileSync(join(targetPath, "blocker"), "x", "utf-8");
+
+    await expect(
+      writePage(
+        workspaceDir,
+        makePage({ slug: "people/alice", body: "interrupted\n" }),
+      ),
+    ).rejects.toThrow();
+
+    rmSync(targetPath, { recursive: true, force: true });
+
+    const peopleDir = join(workspaceDir, "memory", "concepts", "people");
+    const remaining = readdirSync(peopleDir);
+    const orphanTmps = remaining.filter((name) => name.includes(".tmp."));
+    expect(orphanTmps).toEqual([]);
+  });
+
+  test("successful write produces no orphan tmp files", async () => {
+    await writePage(workspaceDir, makePage());
+
+    const remaining = readdirSync(join(workspaceDir, "memory", "concepts"));
+    const orphanTmps = remaining.filter((name) => name.includes(".tmp."));
+    expect(orphanTmps).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listPages
+// ---------------------------------------------------------------------------
+
+describe("listPages", () => {
+  test("returns slugs (filename minus .md) for every page on disk", async () => {
+    await writePage(workspaceDir, makePage({ slug: "alice" }));
+    await writePage(workspaceDir, makePage({ slug: "bob" }));
+    await writePage(workspaceDir, makePage({ slug: "carol" }));
+
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual(["alice", "bob", "carol"]);
+  });
+
+  test("excludes non-.md files in the concepts directory", async () => {
+    await writePage(workspaceDir, makePage({ slug: "alice" }));
+
+    const conceptsDir = join(workspaceDir, "memory", "concepts");
+    writeFileSync(join(conceptsDir, "README.txt"), "ignore me", "utf-8");
+    writeFileSync(join(conceptsDir, "image.png"), "fake", "utf-8");
+    writeFileSync(join(conceptsDir, ".hidden"), "fake", "utf-8");
+
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual(["alice"]);
+  });
+
+  test("walks subdirectories and returns nested slugs in '/'-form", async () => {
+    await writePage(workspaceDir, makePage({ slug: "alice" }));
+    await writePage(workspaceDir, makePage({ slug: "people/bob" }));
+    await writePage(workspaceDir, makePage({ slug: "people/carol" }));
+    await writePage(workspaceDir, makePage({ slug: "arcs/2025-04/cutover" }));
+
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual([
+      "alice",
+      "arcs/2025-04/cutover",
+      "people/bob",
+      "people/carol",
+    ]);
+  });
+
+  test("skips hidden subdirectories and non-.md files inside nested dirs", async () => {
+    await writePage(workspaceDir, makePage({ slug: "people/alice" }));
+
+    const conceptsDir = join(workspaceDir, "memory", "concepts");
+    mkdirSync(join(conceptsDir, ".git"), { recursive: true });
+    writeFileSync(join(conceptsDir, ".git", "config.md"), "fake", "utf-8");
+    writeFileSync(join(conceptsDir, "people", "notes.txt"), "ignore", "utf-8");
+
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual(["people/alice"]);
+  });
+
+  test("skips orphaned .tmp.* files at any depth", async () => {
+    const conceptsDir = join(workspaceDir, "memory", "concepts");
+    await writePage(workspaceDir, makePage({ slug: "people/alice" }));
+
+    // Synthesize an orphan tmp file at root and inside the people/ subdir.
+    writeFileSync(
+      join(conceptsDir, "alice.md.tmp.123.abc-def"),
+      "stranded",
+      "utf-8",
+    );
+    writeFileSync(
+      join(conceptsDir, "people", "bob.md.tmp.123.abc-def"),
+      "stranded",
+      "utf-8",
+    );
+
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual(["people/alice"]);
+  });
+
+  test("returns [] when the concepts directory does not exist", async () => {
+    rmSync(join(workspaceDir, "memory", "concepts"), {
+      recursive: true,
+      force: true,
+    });
+
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual([]);
+  });
+
+  test("returns [] when the concepts directory is empty", async () => {
+    const slugs = await listPages(workspaceDir);
+    expect(slugs).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// deletePage
+// ---------------------------------------------------------------------------
+
+describe("deletePage", () => {
+  test("removes the page from disk", async () => {
+    const page = makePage();
+    await writePage(workspaceDir, page);
+    expect(await pageExists(workspaceDir, page.slug)).toBe(true);
+
+    await deletePage(workspaceDir, page.slug);
+    expect(await pageExists(workspaceDir, page.slug)).toBe(false);
+    expect(await readPage(workspaceDir, page.slug)).toBeNull();
+  });
+
+  test("removes nested pages", async () => {
+    const page = makePage({ slug: "people/alice" });
+    await writePage(workspaceDir, page);
+    expect(await pageExists(workspaceDir, "people/alice")).toBe(true);
+
+    await deletePage(workspaceDir, "people/alice");
+    expect(await pageExists(workspaceDir, "people/alice")).toBe(false);
+  });
+
+  test("is idempotent — deleting a missing page does not throw", async () => {
+    await deletePage(workspaceDir, "never-existed");
+    // Second call still does not throw.
+    await deletePage(workspaceDir, "never-existed");
+  });
+
+  test("does not affect other pages", async () => {
+    await writePage(workspaceDir, makePage({ slug: "alice" }));
+    await writePage(workspaceDir, makePage({ slug: "bob" }));
+
+    await deletePage(workspaceDir, "alice");
+
+    expect(await pageExists(workspaceDir, "alice")).toBe(false);
+    expect(await pageExists(workspaceDir, "bob")).toBe(true);
+  });
+});

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

@@ -0,0 +1,181 @@
+/**
+ * Tests for `assistant/src/memory/v2/prompts/consolidation.ts` —
+ * specifically `resolveConsolidationPrompt` which loads an optional
+ * file-based override and falls back to the bundled prompt when the
+ * override is missing/empty/unreadable.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const warnCalls: Array<{ data: unknown; msg: string }> = [];
+const recordingLogger = {
+  warn: (data: unknown, msg: string) => {
+    warnCalls.push({ data, msg });
+  },
+  info: () => {},
+  debug: () => {},
+  error: () => {},
+  trace: () => {},
+  fatal: () => {},
+  child: () => recordingLogger,
+};
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => recordingLogger,
+}));
+
+let tmpWorkspace: string;
+let previousWorkspaceEnv: string | undefined;
+
+beforeAll(() => {
+  tmpWorkspace = mkdtempSync(join(tmpdir(), "memory-v2-prompt-test-"));
+  previousWorkspaceEnv = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = tmpWorkspace;
+});
+
+afterAll(() => {
+  if (previousWorkspaceEnv === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceEnv;
+  }
+  rmSync(tmpWorkspace, { recursive: true, force: true });
+});
+
+const { CONSOLIDATION_PROMPT, CUTOFF_PLACEHOLDER, resolveConsolidationPrompt } =
+  await import("../prompts/consolidation.js");
+
+const CUTOFF = "2026-05-01T12:00:00.000Z";
+
+const bundledPrompt = (): string =>
+  (CONSOLIDATION_PROMPT as string).replaceAll(CUTOFF_PLACEHOLDER, CUTOFF);
+
+beforeEach(() => {
+  warnCalls.length = 0;
+  mkdirSync(tmpWorkspace, { recursive: true });
+});
+
+afterEach(() => {
+  for (const entry of ["custom-prompt.md", "empty.md", "no-placeholder.md"]) {
+    rmSync(join(tmpWorkspace, entry), { force: true });
+  }
+});
+
+describe("resolveConsolidationPrompt — no override", () => {
+  test("returns the bundled prompt with {{CUTOFF}} substituted when overridePath is null", () => {
+    const result = resolveConsolidationPrompt(null, CUTOFF);
+    expect(result).toContain("You are running memory consolidation");
+    expect(result).toContain(CUTOFF);
+    expect(result).not.toContain(CUTOFF_PLACEHOLDER);
+    expect(warnCalls).toHaveLength(0);
+  });
+});
+
+describe("resolveConsolidationPrompt — with override", () => {
+  test("loads an absolute path verbatim and substitutes {{CUTOFF}}", () => {
+    const path = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(path, "Custom prompt at {{CUTOFF}}\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF);
+
+    expect(result).toBe(`Custom prompt at ${CUTOFF}\n`);
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("resolves a relative path against the workspace dir", () => {
+    writeFileSync(
+      join(tmpWorkspace, "custom-prompt.md"),
+      "Workspace-relative {{CUTOFF}}\n",
+    );
+
+    const result = resolveConsolidationPrompt("custom-prompt.md", CUTOFF);
+
+    expect(result).toBe(`Workspace-relative ${CUTOFF}\n`);
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("expands a leading ~/ to the home directory", () => {
+    const filename = `.vellum-prompt-test-${process.pid}.md`;
+    const path = join(homedir(), filename);
+    writeFileSync(path, "Home dir {{CUTOFF}}\n");
+    try {
+      const result = resolveConsolidationPrompt(`~/${filename}`, CUTOFF);
+      expect(result).toBe(`Home dir ${CUTOFF}\n`);
+      expect(warnCalls).toHaveLength(0);
+    } finally {
+      rmSync(path, { force: true });
+    }
+  });
+
+  test("returns the file body verbatim when {{CUTOFF}} is absent", () => {
+    const body = "No placeholder here. Just a plain prompt.\n";
+    writeFileSync(join(tmpWorkspace, "no-placeholder.md"), body);
+
+    const result = resolveConsolidationPrompt("no-placeholder.md", CUTOFF);
+
+    expect(result).toBe(body);
+    expect(warnCalls).toHaveLength(0);
+  });
+
+  test("substitutes every {{CUTOFF}} occurrence (replaceAll, not replace)", () => {
+    writeFileSync(
+      join(tmpWorkspace, "custom-prompt.md"),
+      "{{CUTOFF}} ... {{CUTOFF}} ... {{CUTOFF}}",
+    );
+
+    const result = resolveConsolidationPrompt("custom-prompt.md", CUTOFF);
+
+    expect(result).toBe(`${CUTOFF} ... ${CUTOFF} ... ${CUTOFF}`);
+    expect(result).not.toContain(CUTOFF_PLACEHOLDER);
+  });
+});
+
+describe("resolveConsolidationPrompt — failure modes", () => {
+  test("falls back to bundled prompt and logs a warning when the file is missing", () => {
+    const result = resolveConsolidationPrompt(
+      "/this/path/does/not/exist.md",
+      CUTOFF,
+    );
+
+    expect(result).toBe(bundledPrompt());
+    expect(warnCalls).toHaveLength(1);
+    const data = warnCalls[0].data as Record<string, unknown>;
+    expect(data.code).toBe("ENOENT");
+    expect(data.fallback).toBe("bundled");
+  });
+
+  test("falls back to bundled prompt when the file is empty", () => {
+    const path = join(tmpWorkspace, "empty.md");
+    writeFileSync(path, "");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF);
+
+    expect(result).toBe(bundledPrompt());
+    expect(warnCalls).toHaveLength(1);
+    const data = warnCalls[0].data as Record<string, unknown>;
+    expect(data.reason).toBe("empty_override");
+  });
+
+  test("falls back to bundled prompt when the file is whitespace-only", () => {
+    const path = join(tmpWorkspace, "empty.md");
+    writeFileSync(path, "   \n\n\t\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF);
+
+    expect(result).toBe(bundledPrompt());
+    expect(warnCalls).toHaveLength(1);
+    const data = warnCalls[0].data as Record<string, unknown>;
+    expect(data.reason).toBe("empty_override");
+  });
+});