@vellumai/assistant 0.11.3 → 0.11.4-staging.1

package/src/plugins/defaults/memory/AGENTS.md

@@ -59,6 +59,10 @@ Everything else under the plugin root is **spine**:
 - Shared infra at the root: `logging`, `paths`, `embeddings`, `anisotropy`,
   `frontmatter`, `validation`, `llm-helpers`, `config`, `memory-db`,
   `host-utils`, `path-containment`, `prompt-override`, `memory-marker`,
+  `buffer-format` (the sole owner of the `memory/buffer.md` entry format:
+  the writer plus the one matcher every reader uses. It lives at the root
+  precisely so `substrate/`, `graph/`, and `graph-topology/` can all reach it
+  without a tier importing spine. Do not add a second matcher anywhere),
   `segmenter`, `message-media`, `worker`, `worker-control`,
   `memory-recall-log-store`, `activation-session-store` (the onboarding
   activation rail — **not** a memory tier despite the name),

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

@@ -0,0 +1,204 @@
+/**
+ * Tests for the single owner of the `memory/buffer.md` entry format.
+ *
+ * These cases pin exactly which lines count as an entry opening, covering the
+ * shapes a second matcher is most likely to get wrong: indentation, spacing
+ * after the bullet dash, and spacing inside the date. Every one of them is the
+ * difference between one fact and two.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  formatBufferTimestamp,
+  formatRememberEntry,
+  isBufferEntryStart,
+  matchBufferEntryStart,
+  splitBufferEntries,
+} from "../buffer-format.js";
+
+describe("matchBufferEntryStart", () => {
+  test("matches what formatRememberEntry writes, and captures both halves", () => {
+    const line = formatRememberEntry(
+      "Alice prefers dark mode",
+      new Date(2026, 0, 1, 9, 0),
+    ).trimEnd();
+    expect(line).toBe("- [Jan 1, 9:00 AM] Alice prefers dark mode");
+
+    const match = matchBufferEntryStart(line);
+    expect(match).toEqual({
+      timestamp: "Jan 1, 9:00 AM",
+      text: "Alice prefers dark mode",
+    });
+  });
+
+  test("round-trips every hour so the AM/PM and 12-hour edges hold", () => {
+    for (let hour = 0; hour < 24; hour++) {
+      const line = formatRememberEntry(
+        "fact",
+        new Date(2026, 0, 1, hour, 5),
+      ).trimEnd();
+      const match = matchBufferEntryStart(line);
+      expect(match).not.toBeNull();
+      expect(match!.timestamp).toBe(
+        formatBufferTimestamp(new Date(2026, 0, 1, hour, 5)),
+      );
+      expect(match!.text).toBe("fact");
+    }
+  });
+
+  test("an indented entry-shaped line is body text, not a new entry", () => {
+    // The writer puts only an entry's opening line at column 0 and nests the
+    // body under it, so anything indented is part of the fact above it.
+    // Reading it as an entry splits one fact into two nodes in the Memory tab.
+    expect(isBufferEntryStart("  - [Jan 1, 9:00 AM] indented")).toBe(false);
+    expect(isBufferEntryStart("\t- [Jan 1, 9:00 AM] tab-indented")).toBe(false);
+  });
+
+  test("only the writer's exact spacing counts as an entry", () => {
+    // A line the writer could not have produced is body text. Recognizing it
+    // would either split the fact holding it or hand a caller a timestamp in a
+    // shape that no real entry uses, which matters because the consolidation
+    // cutoff is compared against entry timestamps textually.
+    expect(isBufferEntryStart("-[Jan 1, 9:00 AM] no space after dash")).toBe(
+      false,
+    );
+    expect(isBufferEntryStart("-  [Jan 1, 9:00 AM] two spaces")).toBe(false);
+    expect(isBufferEntryStart("- [Jan  1, 9:00 AM] double-spaced date")).toBe(
+      false,
+    );
+    expect(
+      isBufferEntryStart("- [Jan 1, 9:00AM] no space before meridiem"),
+    ).toBe(false);
+  });
+
+  test("day and month widths the writer produces all match", () => {
+    // `formatBufferTimestamp` pads neither the day nor the hour, so single and
+    // double digit forms both occur on disk.
+    for (const line of [
+      "- [Jan 1, 9:00 AM] single-digit day and hour",
+      "- [Dec 31, 12:05 PM] double-digit day and hour",
+      "- [Sep 9, 11:59 PM] boundary",
+    ]) {
+      expect(isBufferEntryStart(line)).toBe(true);
+    }
+  });
+
+  test("continuation bullets carrying other bracketed text are not entries", () => {
+    expect(isBufferEntryStart("  - [ ] a checklist item")).toBe(false);
+    expect(isBufferEntryStart("- [ ] a checklist item")).toBe(false);
+    expect(isBufferEntryStart("- [[wikilink]] bullet")).toBe(false);
+    expect(isBufferEntryStart("  plain prose")).toBe(false);
+    expect(isBufferEntryStart("")).toBe(false);
+  });
+
+  test("tolerates trailing whitespace, which editors add invisibly", () => {
+    expect(isBufferEntryStart("- [Jan 1, 9:00 AM] fact   ")).toBe(true);
+  });
+});
+
+describe("formatRememberEntry round trip", () => {
+  const WRITTEN_AT = new Date(2026, 0, 1, 9, 0);
+
+  test("a fact whose body is itself entry-shaped survives as one entry", () => {
+    const content = "plan:\n- [Jan 2, 9:00 AM] step";
+    const written = formatRememberEntry(content, WRITTEN_AT);
+
+    // The body is nested, so it cannot be mistaken for the next fact.
+    expect(written).toBe(
+      "- [Jan 1, 9:00 AM] plan:\n  - [Jan 2, 9:00 AM] step\n",
+    );
+    expect(splitBufferEntries(written.trimEnd().split("\n"))).toHaveLength(1);
+  });
+
+  test("any content round-trips to exactly one entry", () => {
+    // The delimiter is "canonical entry shape at column 0", so the property
+    // that matters is that no fact body can imitate one, whatever the user
+    // dictated.
+    const adversarial = [
+      "plan:\n- [Jan 2, 9:00 AM] step",
+      "plan:\n- [Jan 2, 9:00 AM] step\n- [Jan 3, 10:15 PM] another",
+      "- [Jan 2, 9:00 AM] body opens with an entry shape",
+      "top\n\n- [Dec 31, 12:05 PM] after a blank line",
+      "top\n  - [Jan 2, 9:00 AM] already indented",
+      "top\n\t- [Jan 2, 9:00 AM] tab indented",
+      "top\n- [ ] checklist\n- [[wikilink]] doc\n- plain bullet",
+      "single line, no body",
+    ];
+
+    for (const content of adversarial) {
+      const written = formatRememberEntry(content, WRITTEN_AT);
+      expect(splitBufferEntries(written.trimEnd().split("\n"))).toHaveLength(1);
+    }
+  });
+
+  test("the fact text a reader recovers is unchanged by nesting", () => {
+    const content = "plan:\n- [Jan 2, 9:00 AM] step";
+    const groups = splitBufferEntries(
+      formatRememberEntry(content, WRITTEN_AT).trimEnd().split("\n"),
+    );
+    // Opening clause on the entry, body carried verbatim under it.
+    expect(groups[0]!.start?.text).toBe("plan:");
+    expect(groups[0]!.lines).toEqual([
+      "- [Jan 1, 9:00 AM] plan:",
+      "  - [Jan 2, 9:00 AM] step",
+    ]);
+  });
+
+  test("blank body lines stay blank rather than becoming whitespace", () => {
+    const written = formatRememberEntry("a\n\nb", WRITTEN_AT);
+    expect(written).toBe("- [Jan 1, 9:00 AM] a\n\n  b\n");
+  });
+});
+
+describe("splitBufferEntries", () => {
+  test("keeps a multiline fact's body with its opening line", () => {
+    const groups = splitBufferEntries([
+      "- [Jan 1, 9:00 AM] first",
+      "- [Jan 2, 9:00 AM] second",
+      "  body of second",
+      "  - [ ] checklist inside second",
+      "  - [Jan 3, 9:00 AM] indented, still second",
+    ]);
+
+    expect(groups).toHaveLength(2);
+    expect(groups[0]!.lines).toEqual(["- [Jan 1, 9:00 AM] first"]);
+    expect(groups[1]!.lines).toHaveLength(4);
+    expect(groups[1]!.start?.text).toBe("second");
+    expect(groups[1]!.firstLine).toBe(1);
+  });
+
+  test("surfaces leading prose as a headless group rather than dropping it", () => {
+    const groups = splitBufferEntries([
+      "hand-written header",
+      "- [Jan 1, 9:00 AM] first",
+    ]);
+
+    expect(groups).toHaveLength(2);
+    expect(groups[0]!.start).toBeNull();
+    expect(groups[0]!.lines).toEqual(["hand-written header"]);
+    expect(groups[1]!.start).not.toBeNull();
+  });
+
+  test("a buffer with no entries at all is one headless group", () => {
+    const groups = splitBufferEntries(["just prose", "more prose"]);
+    expect(groups).toHaveLength(1);
+    expect(groups[0]!.start).toBeNull();
+    expect(groups[0]!.lines).toHaveLength(2);
+  });
+
+  test("preserves every input line exactly once, in order", () => {
+    const lines = [
+      "prose",
+      "- [Jan 1, 9:00 AM] a",
+      "  body",
+      "",
+      "- [Jan 2, 9:00 AM] b",
+    ];
+    expect(splitBufferEntries(lines).flatMap((g) => g.lines)).toEqual(lines);
+  });
+
+  test("empty input yields no groups", () => {
+    expect(splitBufferEntries([])).toEqual([]);
+  });
+});

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/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/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",

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

@@ -18,7 +18,10 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 
-import { formatRememberEntry } from "../graph/tool-handlers.js";
+import {
+  formatRememberEntry,
+  matchBufferEntryStart,
+} from "../buffer-format.js";
 import type { MemoryGraphEdge, MemoryGraphNode } from "./types.js";
 
 /** Node id prefix marking a pending buffer entry (id = prefix + text hash). */
@@ -36,15 +39,6 @@ const MAX_PENDING_NODES = 200;
 
 const PENDING_LABEL_MAX_CHARS = 60;
 
-/**
- * Matches a real entry start: `- [Mon D, h:mm AM/PM] fact`, the exact shape
- * `formatRememberEntry` writes. The timestamp must be present and
- * timestamp-shaped — a bullet with other bracketed text (e.g. a `- [ ]`
- * checklist item inside a multiline fact) is a continuation, not an entry.
- */
-const BUFFER_ENTRY_REGEX =
-  /^-\s+\[[A-Z][a-z]{2}\s+\d{1,2},\s+\d{1,2}:\d{2}\s+[AP]M\]\s*(.*)$/;
-
 /** Lenient fallback for hand-written buffers: a plain bullet with no
  * timestamped entry seen yet still counts as an entry of its own. */
 const PLAIN_BULLET_REGEX = /^-\s+(.+)$/;
@@ -102,10 +96,12 @@ export function parseBufferEntries(content: string): PendingBufferEntry[] {
 
   for (const rawLine of content.split("\n")) {
     const line = rawLine.trimEnd();
-    const entryStart = BUFFER_ENTRY_REGEX.exec(line.trim());
+    // Matched against the untrimmed line: an indented entry-shaped bullet is
+    // body text inside the fact above it, not a fact of its own.
+    const entryStart = matchBufferEntryStart(line);
     if (entryStart) {
       flush();
-      current = [entryStart[1]!.trim()];
+      current = [entryStart.text];
       continue;
     }
     if (current !== null) {

package/src/plugins/defaults/memory/hooks/post-compact.ts

@@ -70,10 +70,7 @@ const postCompact: HookFunction<PostCompactContext> = async (ctx) => {
   // concurrent request's actor and the contact/member registry the actor
   // context derives from can be mutated by contact tools. The snapshots are the
   // values the turn's initial assembly resolved.
-  const trust =
-    conversation?.currentTurnTrustContext ??
-    conversation?.trustContext ??
-    FALLBACK_TURN_TRUST;
+  const trust = conversation?.getTurnOrRestingTrust() ?? FALLBACK_TURN_TRUST;
   const actorContext = conversation?.currentTurnInboundActorContext ?? null;
   // Render the `model_profile:` label from the turn-start notice key, using
   // the call site self-resolved from the live conversation — the same