@vellumai/assistant 0.12.2 → 0.12.3-staging.1

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

@@ -10,10 +10,13 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  bufferEntryText,
   formatBufferTimestamp,
   formatRememberEntry,
   isBufferEntryStart,
+  joinBufferEntries,
   matchBufferEntryStart,
+  splitBufferContent,
   splitBufferEntries,
 } from "../buffer-format.js";
 
@@ -202,3 +205,43 @@ describe("splitBufferEntries", () => {
     expect(splitBufferEntries([])).toEqual([]);
   });
 });
+
+describe("splitBufferContent / joinBufferEntries", () => {
+  const content =
+    formatRememberEntry("Alice prefers dark mode", new Date(2026, 0, 1, 9, 0)) +
+    formatRememberEntry(
+      "Bob's plan:\n- [ ] step one\n\nend",
+      new Date(2026, 0, 1, 9, 1),
+    );
+
+  test("round-trips newline-terminated content byte for byte", () => {
+    expect(joinBufferEntries(splitBufferContent(content))).toBe(content);
+  });
+
+  test("an entry's text is the same whether or not it is last in the file", () => {
+    const [first] = splitBufferContent(content);
+    const [alone] = splitBufferContent(
+      formatRememberEntry(
+        "Alice prefers dark mode",
+        new Date(2026, 0, 1, 9, 0),
+      ),
+    );
+    expect(bufferEntryText(alone!)).toBe(bufferEntryText(first!));
+    expect(bufferEntryText(alone!)).toBe(
+      "- [Jan 1, 9:00 AM] Alice prefers dark mode",
+    );
+  });
+
+  test("empty content has no entries and joins back to empty", () => {
+    expect(splitBufferContent("")).toEqual([]);
+    expect(joinBufferEntries([])).toBe("");
+  });
+
+  test("content without a terminating newline keeps its last line intact", () => {
+    const entries = splitBufferContent("- [Jan 1, 9:00 AM] partial appe");
+    expect(entries).toHaveLength(1);
+    expect(bufferEntryText(entries[0]!)).toBe(
+      "- [Jan 1, 9:00 AM] partial appe",
+    );
+  });
+});

package/src/plugins/defaults/memory/__tests__/conversation-memory-purge.test.ts

@@ -60,6 +60,7 @@ describe("conversation memory purge", () => {
         "memory_v2_activation_logs",
         "memory_v3_ever_injected",
         "memory_v3_injected_sections",
+        "memory_v3_pool_inputs",
         "memory_v3_pools",
         "memory_v3_selections",
       ].sort(),

package/src/plugins/defaults/memory/__tests__/db-memory-attach.test.ts

@@ -68,6 +68,8 @@ describe("memory database connection", () => {
     "memory_recall_logs",
     "memory_v3_selections",
     "memory_v3_pools",
+    "memory_v3_pool_inputs",
+    "memory_v3_pool_texts",
     "activation_sessions",
     "activation_state",
     "conversation_graph_memory_state",

package/src/plugins/defaults/memory/__tests__/fixtures/buffer-appender.ts

@@ -0,0 +1,17 @@
+// Child process for the buffer-file cross-process test: appends `count`
+// uniquely tagged entries to `bufferPath` as fast as it can, through the same
+// `appendFileSync` call the production appender uses. Hand-formats the entry
+// line so the fixture imports nothing from `src/`.
+//
+// usage: bun buffer-appender.ts <bufferPath> <count> <tag>
+
+import { appendFileSync } from "node:fs";
+
+const [bufferPath, countArg, tag] = process.argv.slice(2);
+if (!bufferPath || !countArg || !tag) {
+  throw new Error("usage: buffer-appender <bufferPath> <count> <tag>");
+}
+const count = Number.parseInt(countArg, 10);
+for (let i = 0; i < count; i++) {
+  appendFileSync(bufferPath, `- [Apr 27, 9:00 AM] ${tag}-${i}\n`, "utf-8");
+}

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

@@ -117,6 +117,21 @@ let loadedConversations: Record<string, { processing: boolean }> = {};
 // the stale-flag override's age check. Absent ids read as null (stampless).
 let processingStartedAtById: Record<string, number | null> = {};
 
+// The source conversation's recorded wire surface (what its last live turn
+// sent to the provider, and whether that turn's prompt rendered the
+// delegation section). `null` = no live turn has recorded one yet.
+let mockSourceToolSurface: {
+  tools: Array<Record<string, unknown>>;
+  delegateIndependentTasks: boolean | null;
+} | null = null;
+let toolSurfaceReads: string[] = [];
+mock.module("../../../../persistence/conversation-tool-surface.js", () => ({
+  getConversationToolSurface: (conversationId: string) => {
+    toolSurfaceReads.push(conversationId);
+    return mockSourceToolSurface;
+  },
+}));
+
 const watchdogEvents: Array<{
   checkName: string;
   value?: number | null;
@@ -509,6 +524,8 @@ describe("memoryRetrospectiveJob", () => {
     resolveUserSlugCalls = [];
     mockV3TierActive = true;
     mockSkillImprovementActive = false;
+    mockSourceToolSurface = null;
+    toolSurfaceReads = [];
   });
 
   test("first-run happy path: no state row, no prior retrospective, both pointer fields set on success", async () => {
@@ -1842,6 +1859,63 @@ describe("memoryRetrospectiveJob", () => {
     });
   });
 
+  test("replays the source's recorded wire tool surface verbatim on the fork wake", async () => {
+    mockSourceToolSurface = {
+      tools: [
+        { name: "bash", description: "Run", input_schema: {} },
+        { name: "remember", description: "Save", input_schema: {} },
+        { name: "bell_jingle", description: "Ring", input_schema: {} },
+        { type: "web_search_20250305", name: "web_search", max_uses: 5 },
+      ],
+      delegateIndependentTasks: true,
+    };
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(toolSurfaceReads).toEqual(["src-conv-1"]);
+    expect(wakeCalls).toHaveLength(1);
+    // The exact recorded array rides to the wake; the fork sends it in place
+    // of the surface it would resolve for itself.
+    expect(wakeCalls[0]!.opts.wireToolDefinitions).toEqual(
+      mockSourceToolSurface.tools,
+    );
+    // The delegation-section state the source's prompt rendered rides with
+    // it, so the fork's system prompt matches too.
+    expect(wakeCalls[0]!.opts.delegateIndependentTasks).toBe(true);
+    // The execution-side pin still rides alongside it.
+    expect(wakeCalls[0]!.opts.toolGateMode).toBe("execution");
+    expect(wakeCalls[0]!.opts.toolContextPin).toBeDefined();
+  });
+
+  test("a surface recorded without the delegation state leaves the fork to derive the section", async () => {
+    // A row written before the state was recorded: the array still replays,
+    // and the prompt gate falls back to the wake's own answer.
+    mockSourceToolSurface = {
+      tools: [{ name: "remember", description: "Save", input_schema: {} }],
+      delegateIndependentTasks: null,
+    };
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(wakeCalls).toHaveLength(1);
+    expect(wakeCalls[0]!.opts.wireToolDefinitions).toEqual(
+      mockSourceToolSurface.tools,
+    );
+    expect("delegateIndependentTasks" in wakeCalls[0]!.opts).toBe(false);
+  });
+
+  test("no recorded source surface → no wireToolDefinitions; the pin alone shapes the wire", async () => {
+    mockSourceToolSurface = null;
+
+    await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(toolSurfaceReads).toEqual(["src-conv-1"]);
+    expect(wakeCalls).toHaveLength(1);
+    expect("wireToolDefinitions" in wakeCalls[0]!.opts).toBe(false);
+    expect("delegateIndependentTasks" in wakeCalls[0]!.opts).toBe(false);
+    expect(wakeCalls[0]!.opts.toolContextPin).toBeDefined();
+  });
+
   test("execution mode is unconditional → toolContextPin rides even without a resolved profile", async () => {
     await memoryRetrospectiveJob(
       makeJob(),

package/src/plugins/defaults/memory/__tests__/memory-run-evidence.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests for `memory-run-evidence.ts`: the readers of what a background
+ * memory run durably produced, shared by the retrospective's cursor advance
+ * and consolidation's buffer consumption.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  collectSuccessfulToolResultIds,
+  countDurableToolUses,
+  endsWithTextReply,
+  extractRememberContents,
+  hasCommittedTextReply,
+  type MessageLike,
+} from "../memory-run-evidence.js";
+
+const DURABLE = new Set(["file_write", "remember"]);
+
+/**
+ * Persisted message rows carry their blocks as a JSON string; the readers
+ * parse it. Rows are built that way here so the test exercises the same
+ * shape the jobs read.
+ */
+function row(role: string, blocks: unknown[]): MessageLike {
+  return { role, content: JSON.stringify(blocks) };
+}
+const use = (id: string, name: string, input: unknown = {}) => ({
+  type: "tool_use",
+  id,
+  name,
+  input,
+});
+const result = (id: string, isError = false) => ({
+  type: "tool_result",
+  tool_use_id: id,
+  is_error: isError,
+  content: "…",
+});
+const text = (value: string) => ({ type: "text", text: value });
+
+describe("collectSuccessfulToolResultIds", () => {
+  test("collects non-error tool_result ids from user rows only, tolerating malformed rows", () => {
+    const ids = collectSuccessfulToolResultIds([
+      row("user", [result("ok"), result("bad", true)]),
+      row("assistant", [result("not-a-user-row")]),
+      { role: "user", content: "{not json" },
+      row("user", [result("second")]),
+    ]);
+    expect([...ids].sort()).toEqual(["ok", "second"]);
+  });
+});
+
+describe("countDurableToolUses", () => {
+  const messages = [
+    row("assistant", [
+      use("a", "file_write"),
+      use("b", "file_write"),
+      use("c", "file_read"),
+    ]),
+    row("user", [result("a"), result("b", true), result("c")]),
+  ];
+
+  test("counts only the named tools, and with a success set only verified executions", () => {
+    expect(countDurableToolUses(messages, DURABLE, null)).toBe(2);
+    expect(
+      countDurableToolUses(
+        messages,
+        DURABLE,
+        collectSuccessfulToolResultIds(messages),
+      ),
+    ).toBe(1);
+    expect(countDurableToolUses(messages, new Set(["file_read"]), null)).toBe(
+      1,
+    );
+  });
+});
+
+describe("hasCommittedTextReply", () => {
+  test("true only when the LAST assistant row carries non-blank text", () => {
+    expect(
+      hasCommittedTextReply([
+        row("assistant", [text("narrating")]),
+        row("assistant", [text("   ")]),
+      ]),
+    ).toBe(false);
+    expect(
+      hasCommittedTextReply([
+        row("assistant", [use("a", "file_write")]),
+        row("user", [result("a")]),
+        row("assistant", [text("Done.")]),
+      ]),
+    ).toBe(true);
+    expect(hasCommittedTextReply([{ role: "assistant", content: "{" }])).toBe(
+      false,
+    );
+  });
+});
+
+describe("endsWithTextReply", () => {
+  test("true only when the final row is an assistant reply with text and no tool call", () => {
+    expect(
+      endsWithTextReply([
+        row("assistant", [use("a", "file_write")]),
+        row("user", [result("a")]),
+        row("assistant", [text("Filed it.")]),
+      ]),
+    ).toBe(true);
+    // Narration on the row that also calls a tool, then a tool result: the
+    // run stopped mid-loop, whatever the narration said.
+    expect(
+      endsWithTextReply([
+        row("assistant", [
+          text("Fixing that page now."),
+          use("a", "file_write"),
+        ]),
+        row("user", [result("a")]),
+      ]),
+    ).toBe(false);
+    expect(
+      endsWithTextReply([
+        row("assistant", [text("Done."), use("b", "file_read")]),
+      ]),
+    ).toBe(false);
+    expect(endsWithTextReply([row("assistant", [text("   ")])])).toBe(false);
+    expect(endsWithTextReply([{ role: "assistant", content: "{" }])).toBe(
+      false,
+    );
+    expect(endsWithTextReply([])).toBe(false);
+  });
+});
+
+describe("extractRememberContents", () => {
+  const messages = [
+    row("assistant", [
+      use("a", "remember", { content: " one " }),
+      use("b", "remember", { content: ["two", "", "three"] }),
+      use("c", "remember", { content: "failed" }),
+      use("d", "file_write", { content: "not a remember" }),
+    ]),
+    row("user", [result("a"), result("b"), result("c", true)]),
+  ];
+
+  test("flattens batched facts, trims, and drops blanks", () => {
+    expect(extractRememberContents(messages)).toEqual([
+      "one",
+      "two",
+      "three",
+      "failed",
+    ]);
+  });
+
+  test("with a success set, a failed remember's facts are excluded", () => {
+    expect(
+      extractRememberContents(
+        messages,
+        collectSuccessfulToolResultIds(messages),
+      ),
+    ).toEqual(["one", "two", "three"]);
+  });
+});

package/src/plugins/defaults/memory/__tests__/relocated-memory-test-rows.ts

@@ -52,6 +52,16 @@ export function seedRelocatedMemoryRow(
         )
         .run(conversationId, now);
       return;
+    case "memory_v3_pool_inputs":
+      raw
+        .query(
+          `INSERT INTO memory_v3_pool_inputs
+             (conversation_id, turn, created_at, recent_context, current_message,
+              candidate_text_hashes_json)
+           VALUES (?, 1, ?, '', '', '[]')`,
+        )
+        .run(conversationId, now);
+      return;
     case "activation_sessions":
       raw
         .query(