@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

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

@@ -0,0 +1,208 @@
+/**
+ * Tests for `substrate/page-links.ts`: the single owner of `links:` entry and
+ * `[[wikilink]]` parsing, plus the dangling-link finder every write-side
+ * report uses.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  extractWikilinkTargets,
+  findDanglingLinks,
+  LINK_SEPARATOR,
+  parseLinkEntry,
+  WIKILINK_REGEX,
+  wikilinkTarget,
+} from "../page-links.js";
+import { isValidSlug } from "../page-store.js";
+
+/** Build a `"<slug> <sep> <why>"` links entry without spelling the separator. */
+const link = (target: string, why?: string): string =>
+  why === undefined ? target : `${target}${LINK_SEPARATOR}${why}`;
+
+describe("LINK_SEPARATOR", () => {
+  test("is space, U+2014 EM DASH, space", () => {
+    expect(LINK_SEPARATOR).toHaveLength(3);
+    expect(LINK_SEPARATOR.codePointAt(1)).toBe(0x2014);
+    expect(LINK_SEPARATOR[0]).toBe(" ");
+    expect(LINK_SEPARATOR[2]).toBe(" ");
+  });
+});
+
+describe("parseLinkEntry", () => {
+  test("splits target and description on the first separator", () => {
+    expect(parseLinkEntry(link("alice", "the principal"))).toEqual({
+      target: "alice",
+      description: "the principal",
+    });
+  });
+
+  test("keeps later separators inside the description", () => {
+    const why = `why${LINK_SEPARATOR}with a second dash`;
+    expect(parseLinkEntry(link("alice", why))).toEqual({
+      target: "alice",
+      description: why,
+    });
+  });
+
+  test("a bare slug carries no description; whitespace is trimmed", () => {
+    expect(parseLinkEntry("  alice  ")).toEqual({
+      target: "alice",
+      description: undefined,
+    });
+  });
+
+  test("an empty annotation after the separator reads as no description", () => {
+    expect(parseLinkEntry(`alice${LINK_SEPARATOR}  `)).toEqual({
+      target: "alice",
+      description: undefined,
+    });
+  });
+});
+
+describe("wikilinkTarget / extractWikilinkTargets", () => {
+  test("strips |display and #anchor suffixes and trims", () => {
+    expect(wikilinkTarget("alice")).toBe("alice");
+    expect(wikilinkTarget("alice|Alice B.")).toBe("alice");
+    expect(wikilinkTarget("alice#role")).toBe("alice");
+    expect(wikilinkTarget(" tools/vs-code#setup|editor ")).toBe(
+      "tools/vs-code",
+    );
+    expect(wikilinkTarget("|label")).toBe("");
+    expect(wikilinkTarget("#anchor")).toBe("");
+  });
+
+  test("extracts every target in order, dropping empty ones, keeping duplicates", () => {
+    const body =
+      "See [[alice]] and [[bob|Bob]] then [[alice#role]] but not [[|x]] or [[#y]].";
+    expect(extractWikilinkTargets(body)).toEqual(["alice", "bob", "alice"]);
+  });
+
+  test("the regex is global and captures the raw inner text", () => {
+    const matches = [..."[[a|A]] [[b#c]]".matchAll(WIKILINK_REGEX)].map(
+      (m) => m[1],
+    );
+    expect(matches).toEqual(["a|A", "b#c"]);
+  });
+});
+
+describe("findDanglingLinks", () => {
+  const known = new Set(["alice", "bob", "hub", "skills/deploy"]);
+
+  test("reports links:, wikilink, and edges: targets absent from the known set", () => {
+    const result = findDanglingLinks(
+      [
+        {
+          slug: "hub",
+          frontmatter: {
+            links: [link("alice", "principal"), link("atl-1291", "ticket")],
+            edges: ["bob", "ghost-edge"],
+          },
+          body: "Lead mentions [[alice]] and [[ghost-wiki|Ghost]].",
+        },
+      ],
+      known,
+      isValidSlug,
+    );
+    expect(result).toEqual([
+      { from: "hub", to: "atl-1291", kind: "links" },
+      { from: "hub", to: "ghost-edge", kind: "edges" },
+      { from: "hub", to: "ghost-wiki", kind: "wikilink" },
+    ]);
+  });
+
+  test("resolves against synthetic slugs too when the caller counts them as known", () => {
+    expect(
+      findDanglingLinks(
+        [
+          {
+            slug: "alice",
+            frontmatter: { links: [link("skills/deploy")] },
+            body: "",
+          },
+        ],
+        known,
+        isValidSlug,
+      ),
+    ).toEqual([]);
+  });
+
+  test("ignores self-references and empty targets, dedupes per (from, to, kind)", () => {
+    const result = findDanglingLinks(
+      [
+        {
+          slug: "alice",
+          frontmatter: {
+            links: [
+              link("alice", "self"),
+              link("ghost"),
+              link("ghost", "twice"),
+            ],
+          },
+          body: "[[alice]] [[ghost]] [[ghost#sec]] [[|nothing]]",
+        },
+      ],
+      known,
+      isValidSlug,
+    );
+    expect(result).toEqual([
+      { from: "alice", to: "ghost", kind: "links" },
+      { from: "alice", to: "ghost", kind: "wikilink" },
+    ]);
+  });
+
+  test("output is sorted by (from, to, kind) regardless of page order", () => {
+    const pages = [
+      { slug: "zed", frontmatter: { links: [link("nope")] }, body: "[[nope]]" },
+      { slug: "amy", frontmatter: {}, body: "[[zzz]] [[aaa]]" },
+    ];
+    const forward = findDanglingLinks(pages, known, isValidSlug);
+    const reversed = findDanglingLinks(
+      [...pages].reverse(),
+      known,
+      isValidSlug,
+    );
+    expect(forward).toEqual(reversed);
+    expect(forward.map((d) => `${d.from}>${d.to}>${d.kind}`)).toEqual([
+      "amy>aaa>wikilink",
+      "amy>zzz>wikilink",
+      "zed>nope>links",
+      "zed>nope>wikilink",
+    ]);
+  });
+
+  test("targets that are not slug-shaped are not references at all", () => {
+    // Shell tests, code, and prose in double brackets must not be reported
+    // (and so never reach the repair step that would unwrap them).
+    expect(
+      findDanglingLinks(
+        [
+          {
+            slug: "procs/deploy",
+            frontmatter: { links: ["Not A Slug"] },
+            body: "Run `if [[ -f foo ]]; then` and [[ Some Prose ]] then [[real-missing]].",
+          },
+        ],
+        known,
+        isValidSlug,
+      ),
+    ).toEqual([{ from: "procs/deploy", to: "real-missing", kind: "wikilink" }]);
+  });
+
+  test("a fully resolved corpus yields an empty list", () => {
+    expect(
+      findDanglingLinks(
+        [
+          {
+            slug: "alice",
+            frontmatter: { links: [link("bob", "peer")] },
+            body: "[[hub]]",
+          },
+          { slug: "bob", frontmatter: { edges: ["alice"] }, body: "" },
+        ],
+        known,
+        isValidSlug,
+      ),
+    ).toEqual([]);
+  });
+});

package/src/plugins/defaults/memory/substrate/__tests__/prompts-consolidation.test.ts

@@ -66,8 +66,10 @@ const {
   CORE_PAGES_CONSOLIDATION_SECTION,
   CORE_PAGES_PLACEHOLDER,
   CUTOFF_PLACEHOLDER,
+  DANGLING_LINKS_PLACEHOLDER,
   PARSE_FAILURES_PLACEHOLDER,
   renderConsolidationPrompt,
+  renderDanglingLinksSection,
   renderParseFailuresSection,
   resolveConsolidationPrompt,
 } = await import("../prompts/consolidation.js");
@@ -107,7 +109,15 @@ const bundledPrompt = (includeCorePagesSection = false): string =>
         ? (CORE_PAGES_CONSOLIDATION_SECTION as string)
         : "",
     )
-    .replaceAll(PARSE_FAILURES_PLACEHOLDER, "");
+    .replaceAll(PARSE_FAILURES_PLACEHOLDER, "")
+    .replaceAll(DANGLING_LINKS_PLACEHOLDER, "");
+
+/** Sample dangling links for the repair-section tests. */
+const SAMPLE_DANGLING = [
+  { from: "atl-1290", to: "atl-1291", kind: "links" as const },
+  { from: "people/alice", to: "ghost-page", kind: "wikilink" as const },
+  { from: "arcs/day", to: "old-slug", kind: "edges" as const },
+];
 
 beforeEach(() => {
   warnCalls.length = 0;
@@ -316,6 +326,153 @@ describe("resolveConsolidationPrompt — parse-failures repair section", () => {
   });
 });
 
+describe("resolveConsolidationPrompt: dangling-links repair section", () => {
+  test("no dangling links: no section and no placeholder residue, both article shapes", () => {
+    expect(renderDanglingLinksSection([])).toBe("");
+    for (const articleShape of ["v2", "v3"] as const) {
+      const result = renderConsolidationPrompt(CUTOFF, {
+        includeCorePagesSection: false,
+        articleShape,
+      });
+      expect(result).not.toContain("resolve dangling links");
+      expect(result).not.toContain(DANGLING_LINKS_PLACEHOLDER);
+      expect(result).toContain("# The work\n\n## 1. Read the buffer");
+    }
+  });
+
+  test("with dangling links: section renders once, before step 1, one line per reference with its kind", () => {
+    const result = renderConsolidationPrompt(CUTOFF, {
+      ...NO_CORE,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.split("resolve dangling links").length - 1).toBe(1);
+    const sectionAt = result.indexOf("## 0. FIRST: resolve dangling links");
+    expect(sectionAt).toBeGreaterThan(result.indexOf("# The work"));
+    expect(sectionAt).toBeLessThan(result.indexOf("## 1. Read the buffer"));
+    expect(result).toContain(
+      "- `memory/concepts/atl-1290.md` → `atl-1291` (frontmatter `links:` entry)",
+    );
+    expect(result).toContain(
+      "- `memory/concepts/people/alice.md` → `ghost-page` (inline `[[wikilink]]` in the body)",
+    );
+    expect(result).toContain(
+      "- `memory/concepts/arcs/day.md` → `old-slug` (frontmatter `edges:` entry)",
+    );
+    // The three resolutions the agent must choose between.
+    expect(result).toContain("spawn it, a stub is fine, and keep the link");
+    expect(result).toContain("repoint the reference at the surviving slug");
+    expect(result).toContain("Prose stays prose");
+    expect(result).not.toContain("more, reported next pass");
+  });
+
+  test("renders after the parse-failures section when both are present", () => {
+    const result = renderConsolidationPrompt(CUTOFF, {
+      ...NO_CORE,
+      parseFailures: SAMPLE_FAILURES,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.indexOf("repair unreadable pages")).toBeLessThan(
+      result.indexOf("resolve dangling links"),
+    );
+    expect(result.indexOf("resolve dangling links")).toBeLessThan(
+      result.indexOf("## 1. Read the buffer"),
+    );
+  });
+
+  test("caps the rendered list at 40 and counts the remainder", () => {
+    const many = Array.from({ length: 45 }, (_, i) => ({
+      from: `page-${String(i).padStart(2, "0")}`,
+      to: `missing-${i}`,
+      kind: "links" as const,
+    }));
+    const section = renderDanglingLinksSection(many);
+    const listLines = section
+      .split("\n")
+      .filter((line) => line.startsWith("- `memory/concepts/"));
+    expect(listLines).toHaveLength(40);
+    expect(section).toContain("`memory/concepts/page-39.md`");
+    expect(section).not.toContain("`memory/concepts/page-40.md`");
+    expect(section).toContain("...and 5 more, reported next pass");
+  });
+
+  test("sanitizes injection-shaped slugs and targets: newlines, backticks, oversize", () => {
+    // Both ends of a dangling link are page content: the source is a
+    // filename, the target is whatever the page wrote inside `[[...]]` or
+    // `links:`. Raw, either could break out of the list item.
+    const section = renderDanglingLinksSection([
+      {
+        from: "evil\n\n## Injected heading\n- `nested`",
+        to: "target`code`\n## also injected",
+        kind: "wikilink",
+      },
+      { from: "s".repeat(500), to: "t".repeat(500), kind: "links" },
+    ]);
+    const listLines = section
+      .split("\n")
+      .filter((line) => line.startsWith("- `memory/concepts/"));
+    expect(listLines).toHaveLength(2);
+    for (const line of listLines) {
+      // Source path, target, and the kind label's own inline-code span:
+      // six template backticks, no injected ones.
+      expect((line.match(/`/g) ?? []).length).toBe(6);
+    }
+    const headingLines = section
+      .split("\n")
+      .filter((line) => line.startsWith("## "));
+    expect(headingLines).toHaveLength(1);
+    expect(section).toContain("memory/concepts/evil ");
+    expect(section).toContain(`${"s".repeat(199)}…`);
+    expect(section).toContain(`${"t".repeat(199)}…`);
+    expect(section).not.toContain("s".repeat(200));
+    expect(section).not.toContain("t".repeat(200));
+  });
+
+  test("override containing the placeholder: substituted in place", () => {
+    const path = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(path, "Top\n{{DANGLING_LINKS_SECTION}}Bottom\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF, {
+      ...NO_CORE,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result).toContain("## 0. FIRST: resolve dangling links");
+    expect(result.indexOf("resolve dangling links")).toBeLessThan(
+      result.indexOf("Bottom"),
+    );
+    expect(result).not.toContain(DANGLING_LINKS_PLACEHOLDER);
+  });
+
+  test("override without either placeholder: both non-empty repair sections are appended, in order", () => {
+    const path = join(tmpWorkspace, "no-placeholder.md");
+    writeFileSync(path, "My custom prompt {{CUTOFF}}\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF, {
+      ...NO_CORE,
+      parseFailures: SAMPLE_FAILURES,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.startsWith(`My custom prompt ${CUTOFF}`)).toBe(true);
+    const parseAt = result.indexOf("repair unreadable pages");
+    const danglingAt = result.indexOf("resolve dangling links");
+    expect(parseAt).toBeGreaterThan(0);
+    expect(danglingAt).toBeGreaterThan(parseAt);
+    expect(result).toContain("`memory/concepts/atl-1290.md`");
+  });
+
+  test("override with only the parse placeholder + dangling links: dangling section appended", () => {
+    const path = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(path, "Top\n{{PARSE_FAILURES_SECTION}}Bottom\n");
+
+    const result = resolveConsolidationPrompt(path, CUTOFF, {
+      ...NO_CORE,
+      danglingLinks: SAMPLE_DANGLING,
+    });
+    expect(result.indexOf("Bottom")).toBeLessThan(
+      result.indexOf("resolve dangling links"),
+    );
+  });
+});
+
 describe("resolveConsolidationPrompt — with override", () => {
   test("loads an absolute path verbatim and substitutes {{CUTOFF}}", () => {
     const path = join(tmpWorkspace, "custom-prompt.md");

package/src/plugins/defaults/memory/substrate/__tests__/static-context.test.ts

@@ -5,6 +5,7 @@
  *   - Reads the four files in canonical order and joins them under headings.
  *   - Skips empty / missing files.
  *   - Returns null when every file is empty or missing.
+ *   - Caps the Buffer section at `consolidation_max_buffer_lines`.
  */
 
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
@@ -33,17 +34,23 @@ mock.module("../../../../../util/logger.js", () => ({
 
 let configMemoryV2Enabled = true;
 let configMemoryEnabled = true;
+// Mirrors the `memory.v2.consolidation_max_buffer_lines` schema default; the
+// Buffer-cap tests move it.
+let configMaxBufferLines: number | null = 100;
 
-// static-context reads its gates through the plugin's own config accessor.
+// static-context reads its gates and the substrate tuning through the
+// plugin's own config accessor.
 mock.module("../../config.js", () => ({
   getMemoryConfig: () => ({
     enabled: configMemoryEnabled,
-    v2: { enabled: configMemoryV2Enabled },
+    v2: {
+      enabled: configMemoryV2Enabled,
+      consolidation_max_buffer_lines: configMaxBufferLines,
+    },
   }),
 }));
 
-const { readMemoryV2StaticContent, shouldExposePersonalMemory } =
-  await import("../static-context.js");
+const { readMemoryV2StaticContent } = await import("../static-context.js");
 
 const MEMORY_FILES = [
   "essentials.md",
@@ -70,6 +77,7 @@ describe("readMemoryV2StaticContent", () => {
     mkdirSync(TEST_DIR, { recursive: true });
     configMemoryV2Enabled = true;
     configMemoryEnabled = true;
+    configMaxBufferLines = 100;
   });
 
   afterEach(() => {
@@ -165,61 +173,190 @@ describe("readMemoryV2StaticContent", () => {
   });
 });
 
-describe("shouldExposePersonalMemory", () => {
-  test("allows guardian-trusted local conversations", () => {
-    expect(
-      shouldExposePersonalMemory({
-        sourceChannel: "vellum",
-        isTrustedActor: true,
-      }),
-    ).toBe(true);
-  });
-
-  test("allows local-channel conversations even when trust class is unknown (analyze runs, dev)", () => {
-    expect(
-      shouldExposePersonalMemory({
-        sourceChannel: "vellum",
-        isTrustedActor: false,
-      }),
-    ).toBe(true);
-  });
-
-  test("allows turns with no trust context (work-item task runs, internal background)", () => {
-    expect(
-      shouldExposePersonalMemory({
-        sourceChannel: undefined,
-        isTrustedActor: false,
-      }),
-    ).toBe(true);
-  });
-
-  const REMOTE_CHANNELS = [
-    "phone",
-    "slack",
-    "telegram",
-    "whatsapp",
-    "email",
-  ] as const;
-
-  test("allows guardian-trusted remote channels (user's own phone/Slack)", () => {
-    for (const channel of REMOTE_CHANNELS) {
-      expect(
-        shouldExposePersonalMemory({
-          sourceChannel: channel,
-          isTrustedActor: true,
-        }),
-      ).toBe(true);
-    }
+describe("readMemoryV2StaticContent Buffer cap", () => {
+  /** `n` timestamped buffer entries, oldest first, in `remember()`'s shape. */
+  function bufferEntries(n: number): string {
+    return Array.from(
+      { length: n },
+      (_, i) => `- [Jan 1, 9:00 AM] entry-${i}`,
+    ).join("\n");
+  }
+
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    configMemoryV2Enabled = true;
+    configMemoryEnabled = true;
+    configMaxBufferLines = 10;
   });
 
-  test("blocks non-guardian remote-channel actors (the leak this gate exists to prevent)", () => {
-    for (const channel of REMOTE_CHANNELS) {
-      expect(
-        shouldExposePersonalMemory({
-          sourceChannel: channel,
-          isTrustedActor: false,
-        }),
-      ).toBe(false);
-    }
+  afterEach(() => {
+    cleanupMemoryDir();
+  });
+
+  test("passes a buffer at or under the cap through byte-identically", () => {
+    const buffer = bufferEntries(10);
+    writeMemoryFile("buffer.md", buffer);
+
+    expect(readMemoryV2StaticContent()).toBe(`## Buffer\n\n${buffer}`);
+  });
+
+  test("keeps the newest entries and drops the oldest when over the cap", () => {
+    writeMemoryFile("buffer.md", bufferEntries(30));
+
+    const text = readMemoryV2StaticContent()!;
+    expect(text).toContain(
+      "(Older entries trimmed. Read memory/buffer.md for the full backlog.)",
+    );
+    // The cap counts non-empty lines, matching the scheduler's
+    // `countBufferLines`, so exactly the newest 10 entries survive.
+    const kept = text
+      .split("\n")
+      .filter((line) => line.startsWith("- ["))
+      .map((line) => line.slice(line.lastIndexOf(" ") + 1));
+    expect(kept).toEqual(
+      Array.from({ length: 10 }, (_, i) => `entry-${i + 20}`),
+    );
+  });
+
+  test("never opens mid-entry when the cap lands inside a multiline fact", () => {
+    // The 5-line fact straddles the cap: counting back 10 non-empty lines
+    // lands on one of its continuation lines. Injecting from there would show
+    // orphan bullets with no timestamp and no opening clause.
+    const multiline = [
+      "- [Jan 1, 9:00 AM] the straddling fact",
+      "  - [ ] a checklist item inside the fact",
+      "  continuation prose",
+      "  - another bullet",
+      "  closing line",
+    ].join("\n");
+    writeMemoryFile(
+      "buffer.md",
+      `${bufferEntries(20)}\n${multiline}\n${bufferEntries(8)}`,
+    );
+
+    const text = readMemoryV2StaticContent()!;
+    const body = text.slice(text.indexOf("buffer.md for the full backlog.)\n"));
+    const firstLine = body.split("\n")[1]!;
+    expect(firstLine).toMatch(/^- \[Jan 1, 9:00 AM\]/);
+    // The partial entry is dropped whole: none of its continuation lines
+    // survive on their own.
+    expect(text).not.toContain("continuation prose");
+    expect(text).not.toContain("the straddling fact");
+  });
+
+  test("keeps the newest entry attributable when its body alone exceeds the cap", () => {
+    // The newest entry has no successor to fall back to: counting back 10
+    // non-empty lines lands inside its body and there is no later timestamped
+    // entry to open on. Dropping it would leave the section with no facts at
+    // all, so the entry's opening line is kept and its head elided.
+    writeMemoryFile(
+      "buffer.md",
+      [
+        ...Array.from(
+          { length: 20 },
+          (_, i) => `- [Jan 1, 9:00 AM] entry-${i}`,
+        ),
+        "- [Jan 2, 9:00 AM] the oversized fact",
+        ...Array.from({ length: 14 }, (_, i) => `  body line ${i}`),
+      ].join("\n"),
+    );
+
+    const text = readMemoryV2StaticContent()!;
+    const body = text
+      .slice(text.indexOf("full backlog.)\n") + "full backlog.)\n".length)
+      .split("\n")
+      .filter((line) => line.trim().length > 0);
+
+    // Opens on the entry's own timestamped line, never on an orphan body line.
+    expect(body[0]).toBe("- [Jan 2, 9:00 AM] the oversized fact");
+    expect(body[1]).toBe(
+      "(This entry's body was trimmed. Read memory/buffer.md for the rest of it.)",
+    );
+    // The retained tail is the newest end of the body, not its head.
+    expect(body.at(-1)).toBe("  body line 13");
+    expect(body).toContain("  body line 4");
+    expect(body).not.toContain("  body line 3");
+    // Bounded at the cap plus exactly the opening line and the marker, so the
+    // oversized entry cannot reintroduce an unbounded injection.
+    expect(body).toHaveLength(12);
+    // The older entries are still dropped.
+    expect(text).not.toContain("entry-19");
+  });
+
+  test("does not claim a trim when the newest entry's body exactly fills the cap", () => {
+    // The cut lands on the line right after the opening, so nothing of the
+    // entry was elided and the marker would be a lie.
+    writeMemoryFile(
+      "buffer.md",
+      [
+        ...Array.from(
+          { length: 20 },
+          (_, i) => `- [Jan 1, 9:00 AM] entry-${i}`,
+        ),
+        "- [Jan 2, 9:00 AM] the exact-fit fact",
+        ...Array.from({ length: 10 }, (_, i) => `  body line ${i}`),
+      ].join("\n"),
+    );
+
+    const text = readMemoryV2StaticContent()!;
+    const body = text
+      .slice(text.indexOf("full backlog.)\n") + "full backlog.)\n".length)
+      .split("\n")
+      .filter((line) => line.trim().length > 0);
+
+    expect(body[0]).toBe("- [Jan 2, 9:00 AM] the exact-fit fact");
+    expect(text).not.toContain("This entry's body was trimmed");
+    // The entry survives whole: opening line plus its full 10-line body.
+    expect(body).toHaveLength(11);
+    expect(body.at(-1)).toBe("  body line 9");
+    expect(body).toContain("  body line 0");
+  });
+
+  test("keeps a multiline entry intact when it sits fully inside the cap", () => {
+    const multiline = [
+      "- [Jan 1, 9:00 AM] a fact with a body",
+      "  second line of the same fact",
+    ].join("\n");
+    writeMemoryFile("buffer.md", `${bufferEntries(20)}\n${multiline}`);
+
+    const text = readMemoryV2StaticContent()!;
+    expect(text).toContain("a fact with a body");
+    expect(text).toContain("second line of the same fact");
+  });
+
+  test("falls back to the line cut for a buffer with no timestamped entries", () => {
+    // A hand-written buffer that never went through `remember()` has no entry
+    // structure to preserve, so the line-based cut stands rather than dropping
+    // everything.
+    const handWritten = Array.from(
+      { length: 30 },
+      (_, i) => `just a line ${i}`,
+    ).join("\n");
+    writeMemoryFile("buffer.md", handWritten);
+
+    const text = readMemoryV2StaticContent()!;
+    expect(text).toContain("just a line 29");
+    expect(text).not.toContain("just a line 0");
+  });
+
+  test("leaves the buffer unbounded when the size trigger is disabled", () => {
+    configMaxBufferLines = null;
+    const buffer = bufferEntries(30);
+    writeMemoryFile("buffer.md", buffer);
+
+    expect(readMemoryV2StaticContent()).toBe(`## Buffer\n\n${buffer}`);
+  });
+
+  test("caps only the Buffer section, never the curated views", () => {
+    const long = Array.from({ length: 30 }, (_, i) => `line-${i}`).join("\n");
+    writeMemoryFile("essentials.md", long);
+    writeMemoryFile("threads.md", long);
+    writeMemoryFile("recent.md", long);
+    writeMemoryFile("buffer.md", bufferEntries(30));
+
+    const lines = readMemoryV2StaticContent()!.split("\n");
+    expect(lines.filter((line) => line === "line-0")).toHaveLength(3);
+    expect(lines.filter((line) => line === "line-29")).toHaveLength(3);
+    expect(lines.some((line) => line.endsWith("entry-0"))).toBe(false);
   });
 });