@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -193,6 +193,19 @@ mock.module("../skills/version-hash.js", () => ({
   },
 }));
 
+// Mock the skill_loaded telemetry dependencies of conversation-skill-tools so
+// their heavy transitive imports (catalog-install → CLI program, sqlite) stay
+// out of this import-light test.
+mock.module("../skills/catalog-cache.js", () => ({
+  getCachedCatalogSync: () => [],
+}));
+mock.module("../skills/install-meta.js", () => ({
+  readInstallMeta: () => null,
+}));
+mock.module("../memory/skill-loaded-events-store.js", () => ({
+  recordSkillLoadedEvent: () => {},
+}));
+
 // ---------------------------------------------------------------------------
 // Imports under test (after mocks)
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -174,6 +174,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

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");
@@ -922,6 +929,258 @@ describe("forkConversation", () => {
     expect(loadGraphMemoryState(fork.id)).toBeNull();
   });
 
+  test("truncated fork seeds everInjected from inherited memory attachments", async () => {
+    const source = createConversation("Truncated seed thread");
+    await addMessage(source.id, "user", "first turn", {
+      metadata: {
+        memoryInjectedBlock:
+          "# memory/concepts/topics/page-a.md\nSummary A\n\n# memory/concepts/topics/page-b.md\nSummary B",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "first reply", {
+      skipIndexing: true,
+    });
+    const boundaryMessage = await addMessage(source.id, "user", "second turn", {
+      metadata: {
+        memoryInjectedBlock: "# memory/concepts/topics/page-c.md\nSummary C",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "second reply", {
+      skipIndexing: true,
+    });
+    // Past the fork boundary — its attachment must NOT be claimed.
+    await addMessage(source.id, "user", "third turn", {
+      metadata: {
+        memoryInjectedBlock: "# memory/concepts/topics/page-d.md\nSummary D",
+      },
+      skipIndexing: true,
+    });
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: "parent-msg",
+        stateJson: JSON.stringify({ "topics/page-d": 0.9 }),
+        everInjectedJson: JSON.stringify([
+          { slug: "topics/page-a", turn: 1 },
+          { slug: "topics/page-b", turn: 1 },
+          { slug: "topics/page-c", turn: 2 },
+          { slug: "topics/page-d", turn: 3 },
+        ]),
+        currentTurn: 3,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: boundaryMessage.id,
+    });
+
+    const childState = await hydrateActivationState(db, fork.id);
+    expect(childState).not.toBeNull();
+    // Exactly the slugs whose attachments live in the copied history —
+    // page-d (injected past the boundary) stays re-injectable.
+    expect(childState?.everInjected.map((e) => e.slug).sort()).toEqual([
+      "topics/page-a",
+      "topics/page-b",
+      "topics/page-c",
+    ]);
+    expect(childState?.everInjected.every((e) => e.turn === 0)).toBe(true);
+    // Activation scores and the turn counter start fresh, matching the
+    // graph tracker (also not copied for truncated forks).
+    expect(childState?.state).toEqual({});
+    expect(childState?.currentTurn).toBe(0);
+  });
+
+  test("truncated fork ignores attachments behind an inherited compaction boundary", async () => {
+    const source = createConversation("Compacted truncated thread");
+    await addMessage(source.id, "user", "compacted turn", {
+      metadata: {
+        memoryInjectedBlock:
+          "# memory/concepts/topics/page-compacted.md\nOld summary",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "compacted reply", {
+      skipIndexing: true,
+    });
+    const boundaryMessage = await addMessage(source.id, "user", "live turn", {
+      metadata: {
+        memoryInjectedBlock: "# memory/concepts/topics/page-live.md\nSummary",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "live reply", {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "user", "past boundary", {
+      skipIndexing: true,
+    });
+    // First two messages sit behind the compaction boundary: their
+    // attachments are not rendered, so the fork must not claim them.
+    getDb()
+      .update(conversations)
+      .set({ contextCompactedMessageCount: 2 })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: boundaryMessage.id,
+    });
+
+    const childState = await hydrateActivationState(getDb(), fork.id);
+    expect(childState?.everInjected.map((e) => e.slug)).toEqual([
+      "topics/page-live",
+    ]);
+  });
+
+  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-history-web-search.test.ts

@@ -812,7 +812,7 @@ describe("web_search_tool_result structural guard", () => {
     // Downgrades permanently-unsendable images nested in tool_result.contentBlocks
     // (e.g. an oversized browser screenshot). web_search_tool_result has opaque
     // content with no contentBlocks property, so it cannot hold such an image.
-    "daemon/persist-unsendable-image.ts",
+    "plugins/defaults/image-recovery/recover.ts",
 
     // Final orphan-pair safety pass in the Slack transcript renderer.
     // Server-side block types (`server_tool_use`, `web_search_tool_result`)

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__/conversation-process-callsite.test.ts

@@ -259,6 +259,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",