@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/context-search-conversations-source.test.ts

@@ -68,7 +68,7 @@ describe("searchConversationSource", () => {
     ]);
   });
 
-  test("does not return derived subagent or auto-analysis conversations", async () => {
+  test("does not return derived subagent, auto-analysis, or notification conversations", async () => {
     const visible = await seedConversation({
       title: "User conversation",
       content: "derivedtoken belongs to a user-authored conversation.",
@@ -83,6 +83,11 @@ describe("searchConversationSource", () => {
       source: "auto-analysis",
       content: "derivedtoken should not include auto-analysis output.",
     });
+    await seedConversation({
+      title: "Notification conversation",
+      source: "notification",
+      content: "derivedtoken should not include notification seed output.",
+    });
 
     const result = await searchConversationSource(
       "derivedtoken",
@@ -95,22 +100,43 @@ describe("searchConversationSource", () => {
     ]);
   });
 
-  test("does not return legacy private conversations through the FTS path", async () => {
+  test("excludes the current conversation from recall results", async () => {
+    const other = await seedConversation({
+      title: "Other conversation",
+      content: "currenttoken appears in another conversation.",
+    });
+    const current = await seedConversation({
+      title: "Current conversation",
+      content: "currenttoken appears in the active conversation.",
+    });
+
+    const result = await searchConversationSource(
+      "currenttoken",
+      makeContext({ conversationId: current.conversation.id }),
+      10,
+    );
+
+    expect(result.evidence.map((item) => item.locator)).toEqual([
+      `${other.conversation.id}#${other.message.id}`,
+    ]);
+  });
+
+  test("excludes legacy private conversations as defense-in-depth", async () => {
     const visible = await seedConversation({
       title: "Visible conversation",
-      content: "privatesecret belongs to a normal conversation.",
+      content: "privatetoken belongs to a normal conversation.",
     });
-    const hidden = await seedConversation({
-      title: "Private conversation",
-      content: "privatesecret belongs to a private conversation.",
+    const legacyPrivate = await seedConversation({
+      title: "Legacy private conversation",
+      content: "privatetoken belongs to legacy private history.",
     });
     rawRun(
       "UPDATE conversations SET conversation_type = 'private' WHERE id = ?",
-      hidden.conversation.id,
+      legacyPrivate.conversation.id,
     );
 
     const result = await searchConversationSource(
-      "privatesecret",
+      "privatetoken",
       makeContext(),
       10,
     );
@@ -120,21 +146,21 @@ describe("searchConversationSource", () => {
     ]);
   });
 
-  test("does not return legacy private conversations through the LIKE path", async () => {
+  test("excludes legacy private conversations through the LIKE fallback", async () => {
     const visible = await seedConversation({
-      title: "Visible short query conversation",
-      content: "zz appears in a normal conversation.",
+      title: "Visible non-ASCII conversation",
+      content: "東京 appears in a normal conversation.",
     });
-    const hidden = await seedConversation({
-      title: "Private short query conversation",
-      content: "zz appears in a private conversation.",
+    const legacyPrivate = await seedConversation({
+      title: "Legacy private non-ASCII conversation",
+      content: "東京 appears in a private conversation.",
     });
     rawRun(
       "UPDATE conversations SET conversation_type = 'private' WHERE id = ?",
-      hidden.conversation.id,
+      legacyPrivate.conversation.id,
     );
 
-    const result = await searchConversationSource("zz", makeContext(), 10);
+    const result = await searchConversationSource("東京", makeContext(), 10);
 
     expect(result.evidence.map((item) => item.locator)).toEqual([
       `${visible.conversation.id}#${visible.message.id}`,

package/src/__tests__/context-search-fanout.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test";
 
 import type { AssistantConfig } from "../config/schema.js";
 import { formatDeterministicRecallAnswer } from "../memory/context-search/format.js";
-import { RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE } from "../memory/context-search/limits.js";
 import { runDeterministicRecallSearch } from "../memory/context-search/search.js";
 import type {
   RecallEvidence,
@@ -48,185 +47,50 @@ function makeAdapter(
 }
 
 describe("runDeterministicRecallSearch", () => {
-  test("runs only selected source adapters and includes PKB context evidence", async () => {
+  test("runs only selected source adapters", async () => {
     const calls: RecallSource[] = [];
     const result = await runDeterministicRecallSearch(
-      { query: "launch notes", sources: ["pkb", "workspace"], max_results: 5 },
+      {
+        query: "launch notes",
+        sources: ["memory", "workspace"],
+        max_results: 5,
+      },
       makeContext(),
       {
         adapters: [
-          makeAdapter("memory", [makeEvidence("memory")], calls),
           makeAdapter(
-            "pkb",
-            [makeEvidence("pkb", { id: "pkb:search" })],
+            "memory",
+            [makeEvidence("memory", { id: "memory:search" })],
             calls,
           ),
+          makeAdapter("conversations", [makeEvidence("conversations")], calls),
           makeAdapter("workspace", [makeEvidence("workspace")], calls),
         ],
-        readPkbContextEvidence: () => [
-          makeEvidence("pkb", {
-            id: "pkb:auto-inject",
-            title: "PKB auto-injected context",
-            locator: "pkb:auto-inject",
-            excerpt: "Pinned launch plan from context.",
-          }),
-          makeEvidence("pkb", {
-            id: "pkb:NOW.md",
-            title: "NOW.md",
-            locator: "NOW.md",
-            excerpt: "Current launch focus.",
-          }),
-        ],
       },
     );
 
-    expect(calls).toEqual(["pkb", "workspace"]);
+    expect(calls).toEqual(["memory", "workspace"]);
     expect(result.searchedSources.map((note) => note.source)).toEqual([
-      "pkb",
+      "memory",
       "workspace",
     ]);
     expect(result.evidence.map((item) => item.id)).toEqual([
-      "pkb:search",
+      "memory:search",
       "workspace:evidence",
-      "pkb:NOW.md",
-      "pkb:auto-inject",
-    ]);
-  });
-
-  test("does not let PKB auto-injected context displace concrete evidence", async () => {
-    const result = await runDeterministicRecallSearch(
-      { query: "launch notes", sources: ["pkb", "workspace"], max_results: 1 },
-      makeContext(),
-      {
-        adapters: [
-          makeAdapter("pkb", [
-            makeEvidence("pkb", {
-              id: "pkb:search",
-              score: 0.99,
-              excerpt: "High scoring indexed PKB result.",
-            }),
-          ]),
-          makeAdapter("workspace", [
-            makeEvidence("workspace", {
-              id: "workspace:search",
-              score: 1,
-              excerpt: "High scoring workspace result.",
-            }),
-          ]),
-        ],
-        readPkbContextEvidence: () => [
-          makeEvidence("pkb", {
-            id: "pkb:auto-inject",
-            title: "PKB auto-injected context",
-            locator: "pkb:auto-inject",
-            excerpt: "Pinned launch plan from context.",
-          }),
-          makeEvidence("pkb", {
-            id: "pkb:NOW.md",
-            title: "NOW.md",
-            locator: "NOW.md",
-            excerpt: "Current launch focus.",
-          }),
-        ],
-      },
-    );
-
-    expect(result.evidence.map((item) => item.id)).toEqual([
-      "workspace:search",
-    ]);
-    expect(result.searchedSources).toEqual([
-      { source: "pkb", status: "searched", evidenceCount: 0 },
-      { source: "workspace", status: "searched", evidenceCount: 1 },
     ]);
   });
 
-  test("uses PKB auto-injected context when no concrete evidence is available", async () => {
-    const result = await runDeterministicRecallSearch(
-      { query: "launch notes", sources: ["pkb"], max_results: 1 },
-      makeContext(),
-      {
-        adapters: [makeAdapter("pkb", [])],
-        readPkbContextEvidence: () => [
-          makeEvidence("pkb", {
-            id: "pkb:auto-inject",
-            title: "PKB auto-injected context",
-            locator: "pkb:auto-inject",
-            score: 1,
-            excerpt: "A".repeat(RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE * 2),
-          }),
-          makeEvidence("pkb", {
-            id: "pkb:NOW.md",
-            title: "NOW.md",
-            locator: "NOW.md",
-            score: 0.9,
-            excerpt: "Current launch focus.",
-          }),
-        ],
-      },
-    );
-
-    expect(result.evidence.map((item) => item.id)).toEqual(["pkb:auto-inject"]);
-    for (const item of result.evidence) {
-      expect(item.excerpt.length).toBeGreaterThan(0);
-    }
-  });
-
-  test("auto-injected PKB context leaves excerpt budget for exact PKB hits", async () => {
-    const result = await runDeterministicRecallSearch(
-      { query: "where does alice live", sources: ["pkb"], max_results: 3 },
-      makeContext(),
-      {
-        adapters: [
-          makeAdapter("pkb", [
-            makeEvidence("pkb", {
-              id: "pkb:lexical:people/alice.md:5",
-              score: 0.2,
-              excerpt:
-                "5: - Lives at Bob's parents' house in Katy and has her own room.",
-              metadata: { retrieval: "lexical" },
-            }),
-          ]),
-        ],
-        readPkbContextEvidence: () => [
-          makeEvidence("pkb", {
-            id: "pkb:auto-inject",
-            title: "PKB auto-injected context",
-            locator: "pkb:auto-inject",
-            excerpt: "A".repeat(RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE * 2),
-          }),
-          makeEvidence("pkb", {
-            id: "pkb:NOW.md",
-            title: "NOW.md",
-            locator: "NOW.md",
-            excerpt: "B".repeat(RECALL_EVIDENCE_TEXT_CAP_PER_SOURCE * 2),
-          }),
-        ],
-      },
-    );
-
-    expect(result.evidence.map((item) => item.id)).toContain(
-      "pkb:lexical:people/alice.md:5",
-    );
-    expect(
-      result.evidence.find(
-        (item) => item.id === "pkb:lexical:people/alice.md:5",
-      )?.excerpt,
-    ).toContain("Lives at Bob's parents' house in Katy");
-  });
-
   test("searches every source by default", async () => {
     const calls: RecallSource[] = [];
     await runDeterministicRecallSearch({ query: "deployment" }, makeContext(), {
       adapters: [
         makeAdapter("memory", [], calls),
-        makeAdapter("pkb", [], calls),
         makeAdapter("conversations", [], calls),
         makeAdapter("workspace", [], calls),
       ],
-      readPkbContextEvidence: () => [],
     });
 
-    expect(calls).toEqual(["memory", "pkb", "conversations", "workspace"]);
+    expect(calls).toEqual(["memory", "conversations", "workspace"]);
   });
 
   test("isolates adapter failures and reports degraded source notes", async () => {
@@ -304,7 +168,7 @@ describe("runDeterministicRecallSearch", () => {
     const result = await runDeterministicRecallSearch(
       {
         query: "priority",
-        sources: ["workspace", "memory", "pkb"],
+        sources: ["workspace", "memory", "conversations"],
         max_results: 3,
       },
       makeContext(),
@@ -329,26 +193,25 @@ describe("runDeterministicRecallSearch", () => {
               timestampMs: 50,
             }),
           ]),
-          makeAdapter("pkb", [
-            makeEvidence("pkb", {
-              id: "pkb:newer-same-score",
+          makeAdapter("conversations", [
+            makeEvidence("conversations", {
+              id: "conversations:newer-same-score",
               score: 0.7,
               timestampMs: 200,
             }),
-            makeEvidence("pkb", {
-              id: "pkb:source-priority",
+            makeEvidence("conversations", {
+              id: "conversations:source-priority",
               score: 0.4,
               timestampMs: 100,
             }),
           ]),
         ],
-        readPkbContextEvidence: () => [],
       },
     );
 
     expect(result.evidence.map((item) => item.id)).toEqual([
       "workspace:older-high",
-      "pkb:newer-same-score",
+      "conversations:newer-same-score",
       "memory:same-score",
     ]);
   });

package/src/__tests__/context-search-memory-v2-source.test.ts

@@ -181,7 +181,7 @@ describe("searchMemoryV2Source", () => {
     qdrantHits = [{ slug: "alice", denseScore: 0.9 }];
     pageStore.set("alice", {
       slug: "alice",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Alice prefers concise notes.",
     });
 
@@ -297,7 +297,7 @@ describe("searchMemoryV2Source", () => {
     const root = makeTempDir();
     pageStore.set("alice", {
       slug: "alice",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Alice memory body content.",
     });
     qdrantHits = [{ slug: "alice", denseScore: 0.85 }];
@@ -322,7 +322,7 @@ describe("searchMemoryV2Source", () => {
     qdrantHits = [{ slug: "people/alice", denseScore: 0.92 }];
     pageStore.set("people/alice", {
       slug: "people/alice",
-      frontmatter: { edges: [], ref_files: [] },
+      frontmatter: { edges: [], ref_files: [], ref_urls: [] },
       body: "Alice prefers concise notes.",
     });
 

package/src/__tests__/context-search-types.test.ts

@@ -41,8 +41,13 @@ describe("normalizeRecallInput", () => {
 
   test("de-duplicates sources while preserving first-seen order", () => {
     expect(
-      normalizeRecallSources(["workspace", "memory", "workspace", "pkb"]),
-    ).toEqual(["workspace", "memory", "pkb"]);
+      normalizeRecallSources([
+        "workspace",
+        "memory",
+        "workspace",
+        "conversations",
+      ]),
+    ).toEqual(["workspace", "memory", "conversations"]);
   });
 
   test("rejects unknown sources before adapters are run", async () => {