@vellumai/assistant 0.8.0 → 0.8.2

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

@@ -5,6 +5,7 @@ import type { RecallSearchContext } from "../memory/context-search/types.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { rawRun } from "../memory/raw-query.js";
+import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 initializeDb();
 
 let seedId = 0;
@@ -68,7 +69,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 +84,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 +101,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 +147,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}`,
@@ -199,6 +226,99 @@ describe("searchConversationSource", () => {
     );
   });
 
+  test("preserves external_content boundaries in recall evidence", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Slack recall",
+      content:
+        '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
+    });
+
+    const result = await searchConversationSource(
+      "recalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe recalltoken decision came from Slack.\n</external_content>',
+    });
+  });
+
+  test("wraps raw non-guardian Slack recall evidence from metadata", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Raw Slack recall",
+      role: "user",
+      content: "The rawrecalltoken decision came from Slack.",
+      metadata: slackMetadata("1700000100.000000", {
+        provenanceTrustClass: "unknown",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "rawrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe rawrecalltoken decision came from Slack.\n</external_content>',
+    });
+  });
+
+  test("wraps raw non-guardian Slack recall evidence that mentions external_content", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Raw Slack tag mention recall",
+      role: "user",
+      content:
+        "The tagmentionrecalltoken text mentions <external_content but is raw Slack content.",
+      metadata: slackMetadata("1700000102.000000", {
+        provenanceTrustClass: "unknown",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "tagmentionrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt:
+        '<external_content source="slack" origin="@alice">\nThe tagmentionrecalltoken text mentions <external_content but is raw Slack content.\n</external_content>',
+    });
+  });
+
+  test("does not wrap guardian Slack recall evidence", async () => {
+    const { conversation, message } = await seedConversation({
+      title: "Guardian Slack recall",
+      role: "user",
+      content: "The guardianrecalltoken decision came from Slack.",
+      metadata: slackMetadata("1700000101.000000", {
+        provenanceTrustClass: "guardian",
+      }),
+    });
+
+    const result = await searchConversationSource(
+      "guardianrecalltoken",
+      makeContext(),
+      1,
+    );
+
+    expect(result.evidence).toHaveLength(1);
+    expect(result.evidence[0]).toMatchObject({
+      locator: `${conversation.id}#${message.id}`,
+      excerpt: "The guardianrecalltoken decision came from Slack.",
+    });
+  });
+
   test("broadens overconstrained recall queries to salient terms", async () => {
     const specific = await seedConversation({
       title: "Birthday cake plan",
@@ -232,6 +352,7 @@ function seedConversation(opts: {
   memoryScopeId?: string;
   role?: string;
   content: string;
+  metadata?: string;
 }) {
   const id = ++seedId;
   const now = Date.now() + id;
@@ -271,19 +392,39 @@ function seedConversation(opts: {
       conversation_id,
       role,
       content,
-      created_at
-    ) VALUES (?, ?, ?, ?, ?)
+      created_at,
+      metadata
+    ) VALUES (?, ?, ?, ?, ?, ?)
     `,
     message.id,
     conversation.id,
     opts.role ?? "assistant",
     opts.content,
     now,
+    opts.metadata ?? null,
   );
 
   return { conversation, message };
 }
 
+function slackMetadata(
+  channelTs: string,
+  extra: Record<string, unknown>,
+): string {
+  return JSON.stringify({
+    userMessageChannel: "slack",
+    assistantMessageChannel: "slack",
+    slackMeta: writeSlackMetadata({
+      source: "slack",
+      channelId: "C0123",
+      channelTs,
+      eventKind: "message",
+      displayName: "@alice",
+    }),
+    ...extra,
+  });
+}
+
 function makeContext(
   overrides: Partial<RecallSearchContext> = {},
 ): RecallSearchContext {

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

@@ -41,7 +41,6 @@ mock.module("../memory/embedding-backend.js", () => ({
     model: "test-model",
     vectors: [denseEmbedReturn],
   }),
-  generateSparseEmbedding: () => ({ indices: [1], values: [1] }),
 }));
 
 interface QdrantHit {
@@ -181,7 +180,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 +296,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 +321,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 () => {

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

@@ -126,10 +126,15 @@ describe("searchWorkspaceSource", () => {
     writeWorkspaceFile(root, "api-key.md", "needle key");
     writeWorkspaceFile(root, "secret-plan.md", "needle secret");
     writeWorkspaceFile(root, "token-cache.md", "needle token");
+    writeWorkspaceFile(root, "apiKey.json", "needle camel key");
+    writeWorkspaceFile(root, "userToken.txt", "needle camel token");
+    writeWorkspaceFile(root, "MySecret.md", "needle camel secret");
     writeWorkspaceFile(root, "credentials.json", "needle credentials");
     writeWorkspaceFile(root, "protected/readme.md", "needle protected");
     writeWorkspaceFile(root, "gateway-security/readme.md", "needle gateway");
     writeWorkspaceFile(root, "ces-security/readme.md", "needle ces");
+    writeWorkspaceFile(root, "keyboard.ts", "needle keyboard");
+    writeWorkspaceFile(root, "tokenizer.py", "needle tokenizer");
     writeWorkspaceFile(root, "src/readme.md", "needle safe");
 
     const result = await searchWorkspaceSource("needle", makeContext(root), 10);
@@ -138,7 +143,9 @@ describe("searchWorkspaceSource", () => {
       ".hidden.md:1",
       ".notes/.format-rec.md:1",
       ".notes/cake.md:1",
+      "keyboard.ts:1",
       "src/readme.md:1",
+      "tokenizer.py:1",
     ]);
   });
 

package/src/__tests__/context-token-estimator.test.ts

@@ -33,6 +33,7 @@ function makePngBase64(width: number, height: number): string {
 describe("token estimator", () => {
   test("estimates text tokens from character length", () => {
     expect(estimateTextTokens("")).toBe(0);
+    expect(estimateTextTokens(undefined)).toBe(0);
     expect(estimateTextTokens("abcd")).toBe(1);
     expect(estimateTextTokens("abcde")).toBe(2);
   });

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -55,7 +55,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -84,6 +84,7 @@ mock.module("../config/loader.js", () => ({
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     workspaceGit: { turnCommitMaxWaitMs: 10 },
+    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
     ui: {},
   }),
   loadRawConfig: () => ({}),