@vellumai/assistant 0.8.10-dev.202606092334.09948c8 → 0.8.10-dev.202606100317.c8b43c8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.10-dev.202606092334.09948c8",
+  "version": "0.8.10-dev.202606100317.c8b43c8",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-fork-crud.test.ts

@@ -63,6 +63,12 @@ import {
   toolInvocations,
 } from "../memory/schema.js";
 import { hydrate as hydrateActivationState } from "../memory/v2/activation-store.js";
+import {
+  getInjected as getV3Injected,
+  markPruned as markV3Pruned,
+  MEMORY_V3_INJECTED_BLOCK_METADATA_KEY,
+  recordInjected as recordV3Injected,
+} from "../plugins/defaults/memory-v3-shadow/ever-injected-store.js";
 
 initializeDb();
 
@@ -77,6 +83,7 @@ function resetTables(): void {
   db.delete(llmRequestLogs).run();
   db.delete(toolInvocations).run();
   db.delete(memoryJobs).run();
+  db.run("DELETE FROM memory_v3_ever_injected");
   db.run("DELETE FROM message_attachments");
   db.run("DELETE FROM attachments");
   db.run("DELETE FROM messages");
@@ -1032,6 +1039,148 @@ describe("forkConversation", () => {
     ]);
   });
 
+  test("copies the parent's memory-v3 everInjected record into a full fork", async () => {
+    const source = createConversation("V3 carry thread");
+    await addMessage(source.id, "user", "first turn", { skipIndexing: true });
+
+    recordV3Injected(
+      source.id,
+      [
+        { slug: "topics/page-a", bytes: 120 },
+        { slug: "topics/page-b", bytes: 340 },
+      ],
+      1_700_000_000_000,
+    );
+    markV3Pruned(source.id, ["topics/page-b"], 1_700_000_001_000);
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    // Full-row copy, pruned state included.
+    expect(getV3Injected(fork.id)).toEqual(
+      new Map([
+        ["topics/page-a", { bytes: 120, prunedAt: null }],
+        ["topics/page-b", { bytes: 340, prunedAt: 1_700_000_001_000 }],
+      ]),
+    );
+    // Parent record is untouched.
+    expect(getV3Injected(source.id).size).toBe(2);
+  });
+
+  test("leaves the fork's memory-v3 record empty when the parent has none", async () => {
+    const source = createConversation("V3 pristine thread");
+    await addMessage(source.id, "user", "first message", {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(getV3Injected(fork.id).size).toBe(0);
+  });
+
+  test("truncated fork seeds the memory-v3 record from inherited v3 card blocks", async () => {
+    const source = createConversation("V3 truncated seed thread");
+    await addMessage(source.id, "user", "first turn", {
+      metadata: {
+        [MEMORY_V3_INJECTED_BLOCK_METADATA_KEY]:
+          "# memory/concepts/topics/page-a.md\nCard A\n\n# memory/concepts/topics/page-b.md\nCard B",
+        // A v2 block on the same message must seed only the v2 record.
+        memoryInjectedBlock: "# memory/concepts/topics/page-v2.md\nSummary",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "first reply", {
+      skipIndexing: true,
+    });
+    const boundaryMessage = await addMessage(source.id, "user", "second turn", {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "second reply", {
+      skipIndexing: true,
+    });
+    // Past the fork boundary — its card must NOT be claimed.
+    await addMessage(source.id, "user", "third turn", {
+      metadata: {
+        [MEMORY_V3_INJECTED_BLOCK_METADATA_KEY]:
+          "# memory/concepts/topics/page-c.md\nCard C",
+      },
+      skipIndexing: true,
+    });
+
+    recordV3Injected(
+      source.id,
+      [
+        { slug: "topics/page-a", bytes: 120 },
+        { slug: "topics/page-b", bytes: 340 },
+        { slug: "topics/page-c", bytes: 90 },
+      ],
+      1_700_000_000_000,
+    );
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: boundaryMessage.id,
+    });
+
+    // Exactly the slugs whose card blocks live in the copied history,
+    // dedup-only (`bytes = 0` — resident accounting restarts on the child).
+    expect(getV3Injected(fork.id)).toEqual(
+      new Map([
+        ["topics/page-a", { bytes: 0, prunedAt: null }],
+        ["topics/page-b", { bytes: 0, prunedAt: null }],
+      ]),
+    );
+    // The v2 seed picked up only the v2 block, not the v3 cards.
+    const childState = await hydrateActivationState(getDb(), fork.id);
+    expect(childState?.everInjected.map((e) => e.slug)).toEqual([
+      "topics/page-v2",
+    ]);
+  });
+
+  test("truncated fork carries the parent's pruned tombstones for inherited v3 slugs", async () => {
+    // Pruning never rewrites the persisted metadata block, so the fork scan
+    // sees pruned cards' sections too — the seed must tombstone them, or the
+    // child's rehydration would resurrect cards the parent's live view lost.
+    const source = createConversation("V3 truncated pruned thread");
+    await addMessage(source.id, "user", "first turn", {
+      metadata: {
+        [MEMORY_V3_INJECTED_BLOCK_METADATA_KEY]:
+          "# memory/concepts/topics/page-a.md\nCard A\n\n# memory/concepts/topics/page-b.md\nCard B",
+      },
+      skipIndexing: true,
+    });
+    const boundaryMessage = await addMessage(
+      source.id,
+      "assistant",
+      "first reply",
+      { skipIndexing: true },
+    );
+    // Past the fork boundary — forces the truncated-seed path (a fork through
+    // the final message takes the wholesale-copy path instead).
+    await addMessage(source.id, "user", "second turn", { skipIndexing: true });
+
+    recordV3Injected(
+      source.id,
+      [
+        { slug: "topics/page-a", bytes: 120 },
+        { slug: "topics/page-b", bytes: 340 },
+      ],
+      1_700_000_000_000,
+    );
+    markV3Pruned(source.id, ["topics/page-b"], 1_700_000_005_000);
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: boundaryMessage.id,
+    });
+
+    expect(getV3Injected(fork.id)).toEqual(
+      new Map([
+        ["topics/page-a", { bytes: 0, prunedAt: null }],
+        ["topics/page-b", { bytes: 0, prunedAt: 1_700_000_005_000 }],
+      ]),
+    );
+  });
+
   test("defaults conversationType to standard and inherits the parent's group", async () => {
     const source = createConversation("Default inheritance thread");
     await addMessage(source.id, "user", "first message", {

package/src/__tests__/conversation-lifecycle.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 // Stub out heavy dependencies before importing Conversation
 mock.module("../util/logger.js", () => ({
@@ -110,8 +110,38 @@ mock.module("../memory/conversation-queries.js", () => ({
   listConversations: () => [],
 }));
 
+// `loadFromDb` reads the conversation's pruned v3 card slugs (prune valve)
+// when a row carries a `memoryV3InjectedBlock`. Stub the store read so these
+// tests never touch a real DB; the stub DELEGATES to the real implementation
+// unless this file is actively running (`mock.module` is process-global and
+// would otherwise leak into sibling files that use the real store).
+const realEverInjectedStore = {
+  ...(await import("../plugins/defaults/memory-v3-shadow/ever-injected-store.js")),
+};
+let lifecycleStoreMockActive = false;
+let mockPrunedSlugs = new Set<string>();
+mock.module(
+  "../plugins/defaults/memory-v3-shadow/ever-injected-store.js",
+  () => ({
+    ...realEverInjectedStore,
+    getPrunedSlugs: (conversationId: string) =>
+      lifecycleStoreMockActive
+        ? mockPrunedSlugs
+        : realEverInjectedStore.getPrunedSlugs(conversationId),
+  }),
+);
+
 import { Conversation } from "../daemon/conversation.js";
 
+beforeEach(() => {
+  lifecycleStoreMockActive = true;
+  mockPrunedSlugs = new Set();
+});
+
+afterAll(() => {
+  lifecycleStoreMockActive = false;
+});
+
 function makeConversation(): Conversation {
   const provider = {
     name: "mock",
@@ -346,6 +376,156 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
   });
 
+  test("memoryV3InjectedBlock rehydrates wrapped on ALL rows (tail included)", async () => {
+    // The memory-v3 frozen card block persists UNWRAPPED under its own key and
+    // must come back wrapped on every row — including the tail, since the next
+    // turn injects only NET-NEW cards (deduped via the v3 store) and never
+    // re-renders this row's cards.
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryV3InjectedBlock:
+            "header line\n\n# memory/concepts/page-a.md\nhead a",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail turn" }]),
+        metadata: JSON.stringify({
+          memoryV3InjectedBlock: "# memory/concepts/page-b.md\nhead b",
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\nheader line\n\n# memory/concepts/page-a.md\nhead a\n</memory>",
+      },
+      { type: "text", text: "First turn" },
+    ]);
+    // Tail row rehydrates too (unlike turn_context / system_reminder).
+    expect(messages[2].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\n# memory/concepts/page-b.md\nhead b\n</memory>",
+      },
+      { type: "text", text: "Tail turn" },
+    ]);
+  });
+
+  test("pruned slugs' card sections are skipped at v3 rehydration (prune valve persistence)", async () => {
+    // The prune valve marks cards pruned in the everInjected store instead of
+    // rewriting the persisted metadata; the rehydration splice re-filters on
+    // every load, which is what makes a prune survive restarts.
+    mockConversation = defaultConv();
+    mockPrunedSlugs = new Set(["page-a"]);
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryV3InjectedBlock:
+            "header line\n\n# memory/concepts/page-a.md\nhead a\n\n# memory/concepts/page-b.md\nhead b",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory>\nheader line\n\n# memory/concepts/page-b.md\nhead b\n</memory>",
+      },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
+  test("a fully-pruned memoryV3InjectedBlock is skipped entirely at rehydration", async () => {
+    mockConversation = defaultConv();
+    mockPrunedSlugs = new Set(["page-a"]);
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryV3InjectedBlock:
+            "header line\n\n# memory/concepts/page-a.md\nhead a",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    // No memory block at all — an instruction header with zero cards carries
+    // no content (matches the live strip, which removes the emptied block).
+    expect(messages[0].content).toEqual([{ type: "text", text: "First turn" }]);
+  });
+
+  test("defensively-wrapped memoryV3InjectedBlock rehydrates singly-wrapped", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Hi" }]),
+        metadata: JSON.stringify({
+          memoryV3InjectedBlock:
+            "<memory>\n# memory/concepts/page-a.md\nhead a\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    const firstBlock = messages[0].content[0];
+    expect(firstBlock).toEqual({
+      type: "text",
+      text: "<memory>\n# memory/concepts/page-a.md\nhead a\n</memory>",
+    });
+    if (firstBlock.type !== "text") throw new Error("unexpected block type");
+    expect(firstBlock.text.match(/<memory>/g)?.length).toBe(1);
+  });
+
   test("malformed metadata is tolerated: load does not throw, content unchanged", async () => {
     mockConversation = defaultConv();
     mockDbMessages = [
@@ -606,6 +786,82 @@ describe("loadFromDb metadata injection rehydration", () => {
     ]);
   });
 
+  test("rehydration order matches live assembly when memoryV2StaticBlock and memoryV3InjectedBlock co-occur", async () => {
+    // First-turn and first-post-compaction rows of a memory-v3-live
+    // conversation persist BOTH `memoryV2StaticBlock` and the v3 card block.
+    // Live assembly applies after-memory-prefix splices in ascending
+    // injector order (pkb-context 30, pkb-reminder 35, memory-v2-static 38,
+    // now-md 40, memory-v3-shadow 1000); each splice lands at the
+    // memory-prefix boundary (`countMemoryPrefixBlocks` counts `<memory>`
+    // AND `<info>` blocks), so the v3 block — spliced last and itself
+    // `<memory>`-wrapped — lands AFTER the `<info>` static block but before
+    // now-md's earlier splice:
+    //   [<workspace>, <turn_context>, <memory>dynamic</memory>,
+    //    <info>v2static</info>, <memory>v3cards</memory>, <NOW.md>,
+    //    <system_reminder>, <knowledge_base>, ...original]
+    // Rehydration must reproduce this byte-for-byte or every daemon restart
+    // busts the provider prefix cache for the whole conversation history.
+    // (`memoryInjectedBlock` and the v3 key are mutually exclusive on real
+    // rows; both are included here to pin the relative order of all splices.)
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          workspaceBlock: "<workspace>\nworkspace body\n</workspace>",
+          turnContextBlock: "<turn_context>\nctx payload\n</turn_context>",
+          memoryInjectedBlock: "mem payload",
+          memoryV2StaticBlock:
+            "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
+          memoryV3InjectedBlock:
+            "header line\n\n# memory/concepts/page-a.md\nhead a",
+          nowScratchpadBlock: "<NOW.md>\nnow body\n</NOW.md>",
+          pkbSystemReminderBlock:
+            "<system_reminder>\npkb reminder body\n</system_reminder>",
+          pkbContextBlock: "<knowledge_base>\nkb body\n</knowledge_base>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[0].content).toEqual([
+      { type: "text", text: "<workspace>\nworkspace body\n</workspace>" },
+      { type: "text", text: "<turn_context>\nctx payload\n</turn_context>" },
+      { type: "text", text: "<memory>\nmem payload\n</memory>" },
+      {
+        type: "text",
+        text: "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
+      },
+      {
+        type: "text",
+        text: "<memory>\nheader line\n\n# memory/concepts/page-a.md\nhead a\n</memory>",
+      },
+      { type: "text", text: "<NOW.md>\nnow body\n</NOW.md>" },
+      {
+        type: "text",
+        text: "<system_reminder>\npkb reminder body\n</system_reminder>",
+      },
+      { type: "text", text: "<knowledge_base>\nkb body\n</knowledge_base>" },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
   test("untrusted-actor view does not rehydrate memoryV2StaticBlock", async () => {
     mockConversation = defaultConv();
     // Rows with `trusted_contact` / `unknown` provenance survive the

package/src/__tests__/injector-chain.test.ts

@@ -342,16 +342,17 @@ describe("injector chain", () => {
     expect(byName.get("thread-focus")).toBe(DEFAULT_INJECTOR_ORDER.threadFocus);
   });
 
-  test("the injector chain sorts the defaults plus memory-v3 by ascending order", () => {
-    // The assembled chain merges the defaults with the memory-v3 injector and
-    // sorts by `order`, so memory-v3 (order 1000) sits last.
+  test("the injector chain sorts the defaults plus the memory-v3 injectors by ascending order", () => {
+    // The assembled chain merges the defaults with the two memory-v3
+    // injectors and sorts by `order`, so the cards injector (order 1000) and
+    // the spotlight injector (order 1001) sit last, in that order.
     const chain = getInjectorChain();
     const orders = chain.map((i) => i.order);
     expect(orders).toEqual([...orders].sort((a, b) => a - b));
-    expect(chain[chain.length - 1]?.name).toBe("memory-v3-shadow");
     expect(chain.map((i) => i.name)).toEqual([
       ...defaultInjectors.map((i) => i.name),
       "memory-v3-shadow",
+      "memory-v3-spotlight",
     ]);
   });