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

package/src/plugins/defaults/memory/__tests__/memory-retrospective-accounting.test.ts

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { eq } from "drizzle-orm";
+
 import {
   createConversation,
   type MessageRow,
@@ -8,6 +10,7 @@ import { getDb } from "../../../../persistence/db-connection.js";
 import { initializeDb } from "../../../../persistence/db-init.js";
 import { messages } from "../../../../persistence/schema/index.js";
 import {
+  getRetrospectiveMessagesAfter,
   hasQualifyingUserMessageAfter,
   messagesHaveUserActivity,
 } from "../memory-retrospective-accounting.js";
@@ -197,3 +200,72 @@ describe("messagesHaveUserActivity", () => {
     expect(messagesHaveUserActivity([])).toBe(false);
   });
 });
+
+describe("getRetrospectiveMessagesAfter", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+    createConversation({ id: CONV });
+  });
+
+  test("truncates at a stale mid-slice unfinalized row so the cursor never passes it", () => {
+    const first = insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+    const stale = insertRaw({
+      role: "assistant",
+      content: TEXT,
+      createdAt: 2_000,
+    });
+    insertRaw({ role: "user", content: TEXT, createdAt: 3_000 });
+    insertRaw({ role: "assistant", content: TEXT, createdAt: 4_000 });
+    getDb()
+      .update(messages)
+      .set({ finalized: 0 })
+      .where(eq(messages.id, stale))
+      .run();
+
+    const slice = getRetrospectiveMessagesAfter(CONV, null);
+
+    // The slice stops BEFORE the stale row: taking the later finalized rows
+    // as the cutoff would advance the cursor past the stale row, and once it
+    // finalizes it would sit behind the cursor, unreviewed forever.
+    expect(slice.map((row) => row.id)).toEqual([first]);
+
+    getDb()
+      .update(messages)
+      .set({ finalized: 1 })
+      .where(eq(messages.id, stale))
+      .run();
+
+    // Once the row resolves, the slice continues past it.
+    expect(getRetrospectiveMessagesAfter(CONV, null)).toHaveLength(4);
+  });
+
+  test("excludes unfinalized rows so the cutoff stays on rows a fork holds", () => {
+    insertRaw({ role: "user", content: TEXT, createdAt: 1_000 });
+    const lastFinalized = insertRaw({
+      role: "assistant",
+      content: TEXT,
+      createdAt: 2_000,
+    });
+    const streaming = insertRaw({
+      role: "assistant",
+      content: TEXT,
+      createdAt: 3_000,
+    });
+    getDb()
+      .update(messages)
+      .set({ finalized: 0 })
+      .where(eq(messages.id, streaming))
+      .run();
+
+    const slice = getRetrospectiveMessagesAfter(CONV, null);
+
+    // The invariant: no slice member is unfinalized, and the cutoff the job
+    // would take (the last slice row) is a row the retrospective fork
+    // actually contains.
+    expect(slice.some((row) => row.finalized === 0)).toBe(false);
+    expect(slice.at(-1)?.id).toBe(lastFinalized);
+    expect(slice.map((row) => row.id)).not.toContain(streaming);
+  });
+});

package/src/plugins/defaults/memory/__tests__/memory-retrospective-job.test.ts

@@ -168,7 +168,10 @@ mock.module("../find-most-recent-retrospective-for.js", () => ({
 mock.module("../../../../persistence/conversation-crud.js", () => ({
   getMessagesAfter: (id: string, afterId: string | null) => {
     messagesAfterCalls.push({ conversationId: id, afterId });
-    return newMessages;
+    // Real rows always carry `finalized` (NOT NULL, default 1); the slice
+    // filter drops unfinalized rows, so mock rows default to finalized
+    // unless a test explicitly stages a streaming row.
+    return newMessages.map((row) => ({ finalized: 1, ...row }));
   },
   getMessages: (id: string) => {
     if (messagesByConversationId[id]) {

package/src/plugins/defaults/memory/__tests__/memory-retrospective-provider-path.test.ts

@@ -96,7 +96,10 @@ mock.module("../find-most-recent-retrospective-for.js", () => ({
 }));
 
 mock.module("../../../../persistence/conversation-crud.js", () => ({
-  getMessagesAfter: (_id: string, _afterId: string | null) => newMessages,
+  // Real rows always carry `finalized` (NOT NULL, default 1); the slice
+  // filter drops unfinalized rows, so mock rows default to finalized.
+  getMessagesAfter: (_id: string, _afterId: string | null) =>
+    newMessages.map((row) => ({ finalized: 1, ...row })),
   getMessages: (id: string) => messageStores[id] ?? [],
   // `defaultResolveTarget` in the REAL wake reads the FORK id's row for the
   // archived check, so both rows carry archivedAt/createdAt. The fork's

package/src/plugins/defaults/memory/__tests__/memory-tier-boundary-guard.test.ts

@@ -151,7 +151,6 @@ const HOST_TIER_IMPORT_ALLOWLIST: readonly HostTierImportExemption[] = [
   { path: "src/daemon/embedding-reconcile.ts", tiers: ["substrate", "v3"] },
   { path: "src/daemon/skill-memory-refresh.ts", tiers: ["substrate"] },
   { path: "src/daemon/tool-side-effects.ts", tiers: ["substrate"] },
-  { path: "src/daemon/trust-context.ts", tiers: ["substrate"] },
   { path: "src/persistence/steps.ts", tiers: ["v1"] },
   { path: "src/runtime/routes/consolidation-routes.ts", tiers: ["substrate"] },
   {

package/src/plugins/defaults/memory/buffer-format.ts

@@ -0,0 +1,165 @@
+// ---------------------------------------------------------------------------
+// Memory buffer entry format: the single owner
+// ---------------------------------------------------------------------------
+//
+// `memory/buffer.md` is the append-only staging log that `remember()` writes
+// and consolidation drains. Its line format is written here and recognized
+// here, by one matcher, so the writer and every reader agree by construction.
+//
+// This module deliberately sits at the plugin root (shared infra, not a tier)
+// and imports nothing. `substrate/` is the bottom tier and may not import a
+// tier, but plugin-root infra is fair game, so all readers can reach this one
+// without inverting the layering.
+//
+// A second matcher for this format anywhere in the tree is a bug. Two copies
+// disagree on the shapes nobody thinks to test (indentation, spacing after the
+// bullet dash, spacing inside the date), and each disagreement splits or merges
+// somebody's fact.
+
+/**
+ * A parsed buffer entry opening line.
+ */
+export interface BufferEntryStart {
+  /**
+   * The bracketed timestamp, verbatim. Returned unparsed so it can serve
+   * directly as a consolidation cutoff: both sides of the agent's
+   * "timestamp >= cutoff" comparison then share this exact shape.
+   */
+  timestamp: string;
+  /** Everything after the timestamp bracket, trimmed. */
+  text: string;
+}
+
+/**
+ * Matches an entry opening line: `- [Mon D, h:mm AM/PM] fact`, the shape
+ * {@link formatRememberEntry} writes.
+ *
+ * Anchored at column 0, requiring a space after the dash, and spelling the
+ * timestamp with the single spaces {@link formatBufferTimestamp} emits.
+ * Everything else in the file is a continuation line belonging to the entry
+ * above it, which is how a multiline fact keeps its body: `remember()` writes
+ * only the opening line at column 0 and nests the body beneath it. That rule
+ * is what makes a bullet carrying other bracketed text (a `- [ ]` checklist
+ * item, a `- [[wikilink]]` bullet) read as continuation rather than as a new
+ * fact, and it is why a body line can never imitate an opening.
+ *
+ * Matching the writer's exact shape is the conservative choice in both
+ * directions: a line the writer could not have produced stays body text, so an
+ * odd hand-edit merges into the fact around it instead of splitting that fact
+ * or supplying a malformed timestamp to a caller that treats one as a cutoff.
+ *
+ * Group 1 is the timestamp, group 2 the fact text.
+ */
+const BUFFER_ENTRY_REGEX =
+  /^- \[([A-Z][a-z]{2} \d{1,2}, \d{1,2}:\d{2} [AP]M)\]\s*(.*)$/;
+
+/**
+ * Parse `line` as an entry opening, or `null` if it is a continuation line.
+ *
+ * Pass the raw line. Callers must not trim it first: leading whitespace is
+ * exactly what distinguishes an indented body line from a real entry, so a
+ * trimmed line reads an indented body bullet as a fresh fact and splits one
+ * entry into two.
+ */
+export function matchBufferEntryStart(line: string): BufferEntryStart | null {
+  const match = BUFFER_ENTRY_REGEX.exec(line.trimEnd());
+  if (match === null) {
+    return null;
+  }
+  return { timestamp: match[1]!, text: match[2]!.trim() };
+}
+
+/** Whether `line` opens a buffer entry. See {@link matchBufferEntryStart}. */
+export function isBufferEntryStart(line: string): boolean {
+  return BUFFER_ENTRY_REGEX.test(line.trimEnd());
+}
+
+/**
+ * Format `now` as a buffer-entry timestamp (`Mon D, h:mm AM/PM`). Exported so
+ * the consolidation job can present its cutoff in the same shape the buffer
+ * entries use, making the agent's "timestamp >= cutoff" comparison
+ * unambiguous at minute precision.
+ */
+export function formatBufferTimestamp(now: Date): string {
+  const month = now.toLocaleString("en-US", { month: "short" });
+  const day = now.getDate();
+  const hours = now.getHours();
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const displayHour = hours % 12 || 12;
+  return `${month} ${day}, ${displayHour}:${minutes} ${ampm}`;
+}
+
+/**
+ * Indent applied to a fact's continuation lines. Two spaces is the markdown
+ * convention for content nested under a `- ` bullet, so an entry stays
+ * readable as a list item.
+ */
+const CONTINUATION_INDENT = "  ";
+
+/**
+ * Build a timestamped bullet entry for `buffer.md` / `archive/<date>.md`.
+ *
+ * Format mirrors the long-standing v1 PKB layout so buffers stay
+ * human-readable and downstream consumers (sweep, consolidation, the graph
+ * view) can parse the same shape regardless of which path produced the entry.
+ *
+ * A fact's body is indented, which is what makes the format round-trip. The
+ * buffer is line-delimited and the delimiter is "canonical entry shape at
+ * column 0", so a body line carrying that exact shape would otherwise be
+ * indistinguishable from the start of the next fact and split one entry into
+ * two. Indenting moves every body line off column 0, so no fact content can
+ * imitate a delimiter no matter what the user dictated. Blank lines stay
+ * genuinely blank rather than becoming whitespace.
+ *
+ * Readers strip the indent: {@link matchBufferEntryStart} classifies on the
+ * raw line while `parseBufferEntries` trims continuation lines, so the fact
+ * text a caller gets back is unchanged by this.
+ *
+ * Exported so memory sweep / extractor jobs format their auto-remembered
+ * entries identically to user-facing `remember()` calls.
+ */
+export function formatRememberEntry(content: string, now: Date): string {
+  const [opening = "", ...body] = content.split("\n");
+  const nested = body.map((line) =>
+    line.trim().length === 0 ? "" : `${CONTINUATION_INDENT}${line}`,
+  );
+  return `- [${formatBufferTimestamp(now)}] ${[opening, ...nested].join("\n")}\n`;
+}
+
+/**
+ * Split buffer content into entries, each keeping its lines verbatim.
+ *
+ * The unit callers almost always want. Counting or trimming a buffer by raw
+ * lines conflates a five-line fact with five facts, and cuts a fact in half
+ * wherever the count runs out.
+ *
+ * Leading lines that precede the first entry opening (a hand-written buffer,
+ * or stray prose) are returned as a headless first group with
+ * `start === null`, so callers can decide what to do with them rather than
+ * silently dropping content.
+ */
+export function splitBufferEntries(
+  lines: readonly string[],
+): BufferEntryLines[] {
+  const groups: BufferEntryLines[] = [];
+  for (const [index, line] of lines.entries()) {
+    const start = matchBufferEntryStart(line);
+    if (start !== null || groups.length === 0) {
+      groups.push({ start, firstLine: index, lines: [line] });
+      continue;
+    }
+    groups[groups.length - 1]!.lines.push(line);
+  }
+  return groups;
+}
+
+/** One entry's verbatim lines, as returned by {@link splitBufferEntries}. */
+export interface BufferEntryLines {
+  /** `null` for the headless group before the first entry opening. */
+  start: BufferEntryStart | null;
+  /** Index of this group's first line in the input array. */
+  firstLine: number;
+  /** The group's lines, verbatim and in order. */
+  lines: string[];
+}

package/src/plugins/defaults/memory/context-search/sources/conversations.ts

@@ -224,6 +224,12 @@ async function gatherCandidateRowsFromQdrant(
  * the source/type/excluded-conversation predicates in SQL (Qdrant has no
  * visibility filtering). The app-side scorer determines final ordering, so
  * the SQL tie-break falls back to recency.
+ *
+ * No `finalized = 1` predicate, deliberately: every id in `messageIds` comes
+ * from the lexical or vector index, and indexing filters `finalized = 1` at
+ * index time (`message-lexical.ts`), so an unfinalized row can never be a
+ * candidate here. Do not copy this query shape to a reader whose id set has a
+ * different provenance; those need the filter themselves.
  */
 function searchByIds(
   messageIds: readonly string[],

package/src/plugins/defaults/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -371,6 +371,38 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(result.runMessages).toEqual(messages);
   });
 
+  test("separate routing history directs v1 retrieval without replacing model history", async () => {
+    const memory = makeMemory();
+    const config = makeConfig(false);
+    const callerText = "What is my preferred editor?";
+    const continuationText = "Continue the answer.";
+    const routingMessages = makeMessages(callerText);
+    const messages: Message[] = [
+      ...routingMessages,
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: continuationText }],
+      },
+    ];
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+      routingMessages,
+    );
+
+    expect(retrieveForTurnMock).toHaveBeenCalledWith(
+      expect.objectContaining({ userLastMessage: callerText }),
+    );
+    expect(result.runMessages).toEqual(messages);
+  });
+
   test("config on → v2 block prepended, mode is per-turn", async () => {
     stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
 
@@ -498,6 +530,51 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     ).toBe(false);
   });
 
+  test("separate routing history directs v2 retrieval while injection stays on model history", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const callerText = "What is my preferred editor?";
+    const continuationText = "Continue the answer.";
+    const routingMessages = makeMessages(callerText);
+    const messages: Message[] = [
+      ...routingMessages,
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: continuationText }],
+      },
+    ];
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+      routingMessages,
+    );
+
+    expect(generateSparseEmbeddingMock.mock.calls).toContainEqual([callerText]);
+    expect(generateSparseEmbeddingMock.mock.calls).not.toContainEqual([
+      continuationText,
+    ]);
+    const tail = result.runMessages[result.runMessages.length - 1];
+    expect(tail?.role).toBe("user");
+    expect(tail?.content).toContainEqual({
+      type: "text",
+      text: continuationText,
+    });
+    expect(tail?.content[0]).toEqual(expect.objectContaining({ type: "text" }));
+    if (tail?.content[0]?.type !== "text") {
+      throw new Error("unexpected block type");
+    }
+    expect(tail.content[0].text).toContain("# memory/concepts/alice-vscode.md");
+  });
+
   test("config on with empty Qdrant hits → no retrieved concepts in the v2 block, v1 fallback skipped", async () => {
     // No `stageTurn` call — every channel returns `{ points: [] }` so the
     // candidate set is empty and retrieval contributes nothing. Always-candidate

package/src/plugins/defaults/memory/graph/conversation-graph-memory.ts

@@ -512,6 +512,10 @@ export class ConversationGraphMemory {
    * - Turn 1 (or after compaction): full context load
    * - Every other turn: per-turn injection
    *
+   * `routingMessages` may end before an internal continuation message. The
+   * retrievers derive their query from that view, while memory is still
+   * injected into `messages`, which is the history sent to the model.
+   *
    * Returns augmented messages with memory context prepended to the last
    * user message, following the same injection pattern as the old system.
    */
@@ -520,6 +524,7 @@ export class ConversationGraphMemory {
     config: AssistantConfig,
     abortSignal: AbortSignal,
     onEvent: (msg: AssistantEvent) => void,
+    routingMessages: Message[] = messages,
   ): Promise<{
     runMessages: Message[];
     injectedTokens: number;
@@ -579,7 +584,7 @@ export class ConversationGraphMemory {
 
     // Gate: skip for empty/tool-result-only messages — unless we need to
     // reload after compaction (needsReload) or haven't initialized yet.
-    const lastMessage = messages[messages.length - 1];
+    const lastMessage = routingMessages[routingMessages.length - 1];
     if (!lastMessage || lastMessage.role !== "user") {
       return noopResult;
     }
@@ -598,6 +603,7 @@ export class ConversationGraphMemory {
 
         return await this.runContextLoad(
           messages,
+          routingMessages,
           config,
           recentSummaries,
           firstUserText ?? undefined,
@@ -606,7 +612,12 @@ export class ConversationGraphMemory {
         );
       }
 
-      return await this.runPerTurn(messages, config, abortSignal);
+      return await this.runPerTurn(
+        messages,
+        routingMessages,
+        config,
+        abortSignal,
+      );
     } catch (err) {
       const errCode =
         err instanceof z.ZodError ? err.issues[0]?.code : undefined;
@@ -629,6 +640,7 @@ export class ConversationGraphMemory {
 
   private async runContextLoad(
     messages: Message[],
+    routingMessages: Message[],
     config: AssistantConfig,
     recentSummaries: string[],
     userQuery: string | undefined,
@@ -640,9 +652,12 @@ export class ConversationGraphMemory {
     // The activation pipeline is robust to weak ANN signal — it falls back
     // to spreading + nowText to surface candidates.
     const startedAt = Date.now();
-    const rawUserText = readRawUserText(messages[messages.length - 1]);
+    const rawUserText = readRawUserText(
+      routingMessages[routingMessages.length - 1],
+    );
     const v2 = await this.maybeRouteV2Injection(
       messages,
+      routingMessages,
       config,
       "context-load",
       // Context-load runs before the messages array necessarily contains
@@ -780,6 +795,7 @@ export class ConversationGraphMemory {
 
   private async runPerTurn(
     messages: Message[],
+    routingMessages: Message[],
     config: AssistantConfig,
     signal: AbortSignal,
   ) {
@@ -788,8 +804,8 @@ export class ConversationGraphMemory {
     let userLast = "";
     let userLastBlocks: ContentBlock[] = [];
 
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const msg = messages[i];
+    for (let i = routingMessages.length - 1; i >= 0; i--) {
+      const msg = routingMessages[i];
       const text = msg.content
         .filter(
           (b): b is Extract<typeof b, { type: "text" }> => b.type === "text",
@@ -815,6 +831,7 @@ export class ConversationGraphMemory {
     const startedAt = Date.now();
     const v2 = await this.maybeRouteV2Injection(
       messages,
+      routingMessages,
       config,
       "per-turn",
       null,
@@ -978,6 +995,7 @@ export class ConversationGraphMemory {
    */
   private async maybeRouteV2Injection(
     messages: Message[],
+    routingMessages: Message[],
     config: AssistantConfig,
     mode: InjectMemoryV2Mode,
     /**
@@ -1004,7 +1022,7 @@ export class ConversationGraphMemory {
     const recentTurnPairs =
       userMessageOverride !== null
         ? [{ assistantMessage: "", userMessage: userMessageOverride }]
-        : extractRecentTurnPairs(messages, historicalPairs);
+        : extractRecentTurnPairs(routingMessages, historicalPairs);
 
     const result = await injectMemoryV2Block({
       conversationId: this.conversationId,

package/src/plugins/defaults/memory/graph/image-ref-utils.ts

@@ -17,6 +17,9 @@ export async function loadImageRefData(
   const msg = db
     .select({ content: messages.content })
     .from(messages)
+    // No completeness predicate: refs come from the extracted memory graph,
+    // and extraction reads finalized rows only, so an unfinalized id cannot
+    // reach here. Do not copy this shape for ids with other provenance.
     .where(eq(messages.id, ref.messageId))
     .get();
   if (!msg) {

package/src/plugins/defaults/memory/graph/tool-handlers.ts

@@ -15,6 +15,7 @@ import {
 } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import { enqueueMemoryJob } from "../../../../persistence/jobs-store.js";
+import { formatRememberEntry } from "../buffer-format.js";
 import { getWorkspaceDir } from "../paths.js";
 import type { GraphStats } from "./store.js";
 import {
@@ -98,36 +99,6 @@ export function handleRemember(
   return { success: true, message };
 }
 
-/**
- * Format `now` as a buffer-entry timestamp (`Mon D, h:mm AM/PM`). Exported so
- * the memory v2 consolidation job can present its cutoff in the same shape
- * the buffer entries use, making the agent's "timestamp ≥ cutoff" comparison
- * unambiguous at minute precision.
- */
-export function formatBufferTimestamp(now: Date): string {
-  const month = now.toLocaleString("en-US", { month: "short" });
-  const day = now.getDate();
-  const hours = now.getHours();
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const ampm = hours >= 12 ? "PM" : "AM";
-  const displayHour = hours % 12 || 12;
-  return `${month} ${day}, ${displayHour}:${minutes} ${ampm}`;
-}
-
-/**
- * Build a timestamped bullet entry for `buffer.md` / `archive/<date>.md`.
- *
- * Format mirrors the long-standing v1 PKB layout so v2 buffers stay
- * human-readable and downstream consumers (sweep, consolidation) can parse
- * the same shape regardless of which path produced the entry.
- *
- * Exported so memory v2 sweep / extractor jobs format their auto-remembered
- * entries identically to user-facing `remember()` calls.
- */
-export function formatRememberEntry(content: string, now: Date): string {
-  return `- [${formatBufferTimestamp(now)}] ${content}\n`;
-}
-
 /**
  * Append `entry` to `<rootDir>/buffer.md` and `<rootDir>/archive/<today>.md`,
  * creating the archive directory and seeding the archive header if missing.

package/src/plugins/defaults/memory/graph-topology/pending-buffer.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
+import { formatRememberEntry } from "../buffer-format.js";
 import {
   buildPendingGraph,
   findPendingEntryForContent,
@@ -42,6 +43,39 @@ describe("parseBufferEntries", () => {
     expect(entries[1]!.text).toBe("separate fact");
   });
 
+  test("a written fact stays one node even when its body is entry-shaped at column 0", () => {
+    // Round trip through the real writer. A user can dictate a fact whose body
+    // is itself a dated bullet, and without the writer nesting the body those
+    // lines are byte-identical to the start of the next fact, so one memory
+    // renders as several pending nodes in the Memory tab.
+    const entries = parseBufferEntries(
+      formatRememberEntry(
+        "Rollout plan:\n- [Jul 21, 9:00 AM] cutover window opens\n- [Jul 22, 9:00 AM] rollback deadline",
+        new Date(2026, 6, 20, 15, 15),
+      ),
+    );
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0]!.text).toBe(
+      "Rollout plan:\n- [Jul 21, 9:00 AM] cutover window opens\n- [Jul 22, 9:00 AM] rollback deadline",
+    );
+  });
+
+  test("an indented entry-shaped line stays inside the fact above it", () => {
+    // Only an entry's opening line sits at column 0, so an indented bullet
+    // that happens to carry a timestamp is body text the user wrote. Reading
+    // it as an entry splits one fact into two nodes in the Memory tab.
+    const entries = parseBufferEntries(
+      "- [Jul 20, 3:15 PM] Timeline for the migration:\n" +
+        "  - [Jul 21, 9:00 AM] cutover window opens\n" +
+        "  - [Jul 22, 9:00 AM] rollback deadline\n",
+    );
+    expect(entries).toHaveLength(1);
+    expect(entries[0]!.text).toBe(
+      "Timeline for the migration:\n- [Jul 21, 9:00 AM] cutover window opens\n- [Jul 22, 9:00 AM] rollback deadline",
+    );
+  });
+
   test("keeps interior blank lines inside a multiline fact", () => {
     const entries = parseBufferEntries(
       "- [Jul 20, 3:15 PM] first paragraph\n\nsecond paragraph\n- [Jul 20, 3:16 PM] next\n",