@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/contacts-tools.test.ts

@@ -33,8 +33,8 @@ mock.module("../config/env.js", () => ({
   getGatewayPort: () => 0,
 }));
 
-// contact-search now calls cliIpcCall instead of the gateway HTTP.
-// Mock the IPC client to dispatch search_contacts to the real store
+// Skill tools call cliIpcCall instead of the gateway HTTP.
+// Mock the IPC client to dispatch contact reads/merge to the real store
 // (backed by the test DB) without needing a running IPC server.
 mock.module("../ipc/cli-client.js", () => ({
   cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
@@ -44,10 +44,6 @@ mock.module("../ipc/cli-client.js", () => ({
     if (method === "search_contacts") {
       return { ok: true, result: store.searchContacts(body) };
     }
-    if (method === "upsert_contact") {
-      const contact = store.upsertContact(body as never);
-      return { ok: true, result: { ok: true, contact } };
-    }
     if (method === "getContact") {
       const id = pathParams.id ?? (body as { id?: string }).id;
       const contact = id ? store.getContact(id) : null;
@@ -67,7 +63,8 @@ import type { Database } from "bun:sqlite";
 
 import { executeContactMerge } from "../config/bundled-skills/contacts/tools/contact-merge.js";
 import { executeContactSearch } from "../config/bundled-skills/contacts/tools/contact-search.js";
-import { executeContactUpsert } from "../config/bundled-skills/contacts/tools/contact-upsert.js";
+import { upsertContact } from "../contacts/contact-store.js";
+import type { ContactWithChannels } from "../contacts/types.js";
 import { getDb, resetDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/contact-routes.js";
@@ -107,14 +104,6 @@ beforeAll(() => {
           const result = listRoute.handler({ queryParams: qp });
           return Response.json(result);
         }
-        if (path === "/v1/contacts" && req.method === "POST") {
-          const upsertRoute = ROUTES.find(
-            (r) => r.operationId === "upsert_contact",
-          )!;
-          const body = (await req.json()) as Record<string, unknown>;
-          const result = upsertRoute.handler({ body });
-          return Response.json(result);
-        }
       } catch (err) {
         if (err instanceof RouteError) {
           return Response.json(
@@ -156,142 +145,28 @@ function clearContacts(): void {
   getRawDb().run("DELETE FROM contacts");
 }
 
-// ── contact_upsert ──────────────────────────────────────────────────
-
-describe("contact_upsert tool", () => {
-  beforeEach(clearContacts);
-
-  test("creates a new contact with display name only", async () => {
-    const result = await executeContactUpsert({ display_name: "Alice" }, ctx);
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Created contact");
-    expect(result.content).toContain("Alice");
-  });
-
-  test("creates a contact with all fields", async () => {
-    const result = await executeContactUpsert(
-      {
-        display_name: "Bob",
-        notes:
-          "Colleague at Acme Corp, prefers professional tone, responds within hours",
-        channels: [
-          { type: "email", address: "bob@example.com", is_primary: true },
-          { type: "slack", address: "@bob" },
-        ],
-      },
-      ctx,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Bob");
-    expect(result.content).toContain("Notes: Colleague at Acme Corp");
-    expect(result.content).toContain("email: bob@example.com");
-    expect(result.content).toContain("slack: @bob");
+// ── fixture helper ──────────────────────────────────────────────────
+//
+// The contact_upsert skill tool was removed (gateway is now the source of
+// truth — see PR #30141 + the follow-up that deleted this daemon route).
+// For test fixtures we go straight to the store, which is still the
+// underlying write path used by the gateway dual-write and the assistant CLI.
+
+function upsertFixture(params: {
+  display_name: string;
+  notes?: string;
+  channels?: Array<{ type: string; address: string; is_primary?: boolean }>;
+}): ContactWithChannels {
+  return upsertContact({
+    displayName: params.display_name,
+    notes: params.notes,
+    channels: params.channels?.map((ch) => ({
+      type: ch.type,
+      address: ch.address,
+      isPrimary: ch.is_primary,
+    })),
   });
-
-  test("ignores external identity bindings supplied through tool input", async () => {
-    const result = await executeContactUpsert(
-      {
-        display_name: "Eve",
-        channels: [
-          {
-            type: "slack",
-            address: "@eve",
-            external_user_id: "UATTACKER",
-            external_chat_id: "DATTACKER",
-          },
-        ],
-      },
-      ctx,
-    );
-
-    expect(result.isError).toBe(false);
-
-    const row = getRawDb()
-      .query(
-        "SELECT external_user_id, external_chat_id FROM contact_channels WHERE type = 'slack' AND address = '@eve'",
-      )
-      .get() as {
-      external_user_id: string | null;
-      external_chat_id: string | null;
-    };
-
-    expect(row.external_user_id).toBeNull();
-    expect(row.external_chat_id).toBeNull();
-  });
-
-  test("updates an existing contact by ID", async () => {
-    const createResult = await executeContactUpsert(
-      { display_name: "Charlie" },
-      ctx,
-    );
-    expect(createResult.isError).toBe(false);
-
-    // Extract ID from output
-    const idMatch = createResult.content.match(/Contact (\S+)/);
-    expect(idMatch).not.toBeNull();
-    const contactId = idMatch![1];
-
-    const updateResult = await executeContactUpsert(
-      {
-        id: contactId,
-        display_name: "Charlie Updated",
-        notes: "Updated notes for Charlie",
-      },
-      ctx,
-    );
-
-    expect(updateResult.isError).toBe(false);
-    expect(updateResult.content).toContain("Updated contact");
-    expect(updateResult.content).toContain("Charlie Updated");
-    expect(updateResult.content).toContain("Notes: Updated notes for Charlie");
-  });
-
-  test("auto-matches by channel address on create", async () => {
-    // Create a contact with an email
-    await executeContactUpsert(
-      {
-        display_name: "Diana",
-        channels: [{ type: "email", address: "diana@example.com" }],
-      },
-      ctx,
-    );
-
-    // Upsert with same email but different display name
-    const result = await executeContactUpsert(
-      {
-        display_name: "Diana Updated",
-        channels: [{ type: "email", address: "diana@example.com" }],
-      },
-      ctx,
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Updated contact");
-    expect(result.content).toContain("Diana Updated");
-
-    // Should still be just 1 contact
-    const count = getRawDb()
-      .query("SELECT COUNT(*) as c FROM contacts")
-      .get() as { c: number };
-    expect(count.c).toBe(1);
-  });
-
-  test("rejects missing display_name", async () => {
-    const result = await executeContactUpsert({}, ctx);
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("display_name is required");
-  });
-
-  test("rejects empty display_name", async () => {
-    const result = await executeContactUpsert({ display_name: "   " }, ctx);
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("display_name is required");
-  });
-});
+}
 
 // ── contact_search ──────────────────────────────────────────────────
 
@@ -299,8 +174,8 @@ describe("contact_search tool", () => {
   beforeEach(clearContacts);
 
   test("searches by display name", async () => {
-    await executeContactUpsert({ display_name: "Alice Smith" }, ctx);
-    await executeContactUpsert({ display_name: "Bob Jones" }, ctx);
+    upsertFixture({ display_name: "Alice Smith" });
+    upsertFixture({ display_name: "Bob Jones" });
 
     const result = await executeContactSearch({ query: "Alice" }, ctx);
 
@@ -310,13 +185,10 @@ describe("contact_search tool", () => {
   });
 
   test("searches by channel address", async () => {
-    await executeContactUpsert(
-      {
-        display_name: "Charlie",
-        channels: [{ type: "email", address: "charlie@example.com" }],
-      },
-      ctx,
-    );
+    upsertFixture({
+      display_name: "Charlie",
+      channels: [{ type: "email", address: "charlie@example.com" }],
+    });
 
     const result = await executeContactSearch(
       { channel_address: "charlie@example" },
@@ -328,7 +200,7 @@ describe("contact_search tool", () => {
   });
 
   test("returns no results message when nothing matches", async () => {
-    await executeContactUpsert({ display_name: "Existing" }, ctx);
+    upsertFixture({ display_name: "Existing" });
 
     const result = await executeContactSearch({ query: "Nonexistent" }, ctx);
 
@@ -346,16 +218,13 @@ describe("contact_search tool", () => {
   });
 
   test("searches by channel address with type filter", async () => {
-    await executeContactUpsert(
-      {
-        display_name: "Frank",
-        channels: [
-          { type: "email", address: "frank@example.com" },
-          { type: "slack", address: "frank@example.com" },
-        ],
-      },
-      ctx,
-    );
+    upsertFixture({
+      display_name: "Frank",
+      channels: [
+        { type: "email", address: "frank@example.com" },
+        { type: "slack", address: "frank@example.com" },
+      ],
+    });
 
     const result = await executeContactSearch(
       {
@@ -375,32 +244,17 @@ describe("contact_search tool", () => {
 describe("contact_merge tool", () => {
   beforeEach(clearContacts);
 
-  function extractContactId(result: { content: string }): string {
-    const match = result.content.match(/Contact (\S+)/);
-    expect(match).not.toBeNull();
-    return match![1];
-  }
-
   test("merges two contacts", async () => {
-    const r1 = await executeContactUpsert(
-      {
-        display_name: "Alice (Email)",
-        notes: "Prefers email",
-        channels: [{ type: "email", address: "alice@example.com" }],
-      },
-      ctx,
-    );
-    const r2 = await executeContactUpsert(
-      {
-        display_name: "Alice (Slack)",
-        notes: "Active on Slack",
-        channels: [{ type: "slack", address: "@alice" }],
-      },
-      ctx,
-    );
-
-    const keepId = extractContactId(r1);
-    const mergeId = extractContactId(r2);
+    const keepId = upsertFixture({
+      display_name: "Alice (Email)",
+      notes: "Prefers email",
+      channels: [{ type: "email", address: "alice@example.com" }],
+    }).id;
+    const mergeId = upsertFixture({
+      display_name: "Alice (Slack)",
+      notes: "Active on Slack",
+      channels: [{ type: "slack", address: "@alice" }],
+    }).id;
 
     const result = await executeContactMerge(
       {
@@ -438,8 +292,7 @@ describe("contact_merge tool", () => {
   });
 
   test("returns error for nonexistent keep_id", async () => {
-    const r = await executeContactUpsert({ display_name: "Exists" }, ctx);
-    const existingId = extractContactId(r);
+    const existingId = upsertFixture({ display_name: "Exists" }).id;
 
     const result = await executeContactMerge(
       {
@@ -454,8 +307,7 @@ describe("contact_merge tool", () => {
   });
 
   test("returns error for nonexistent merge_id", async () => {
-    const r = await executeContactUpsert({ display_name: "Exists" }, ctx);
-    const existingId = extractContactId(r);
+    const existingId = upsertFixture({ display_name: "Exists" }).id;
 
     const result = await executeContactMerge(
       {

package/src/__tests__/context-search-agent-protocol.test.ts

@@ -51,7 +51,7 @@ describe("recall agent protocol tool definitions", () => {
       schemaProperties(SEARCH_SOURCES_TOOL_DEFINITION).sources.items,
     ).toEqual({
       type: "string",
-      enum: ["memory", "pkb", "conversations", "workspace"],
+      enum: ["memory", "conversations", "workspace"],
     });
     expect(
       schemaProperties(SEARCH_SOURCES_TOOL_DEFINITION).limit,
@@ -214,6 +214,25 @@ describe("recall agent validation helpers", () => {
         citationIds: [],
       },
     });
+
+    expect(
+      validateFinishRecallPayload(
+        {
+          answer: "Confident answer with no supporting evidence.",
+          confidence: "high",
+          citation_ids: [],
+        },
+        [makeEvidence("ev-1")],
+      ),
+    ).toMatchObject({
+      ok: false,
+      reason: "missing_citations",
+      finish: {
+        answer: "No reliable answer could be produced by the recall agent.",
+        confidence: "low",
+        citationIds: [],
+      },
+    });
   });
 
   test("defaults to all source descriptions when available sources are omitted", () => {
@@ -223,7 +242,7 @@ describe("recall agent validation helpers", () => {
     });
 
     expect(prompt).toContain("memory: durable memory graph facts");
-    expect(prompt).toContain("pkb: personal knowledge base");
+    expect(prompt).not.toContain("pkb: personal knowledge base");
     expect(prompt).toContain("conversations: past assistant conversations");
     expect(prompt).toContain("workspace: files and text");
   });

package/src/__tests__/context-search-agent-runner.test.ts

@@ -226,7 +226,11 @@ describe("runAgenticRecall", () => {
     const searchCalls: SearchCall[] = [];
 
     const result = await runAgenticRecall(
-      { query: "Where does Alice live?", sources: ["pkb"], max_results: 5 },
+      {
+        query: "Where does Alice live?",
+        sources: ["conversations"],
+        max_results: 5,
+      },
       makeContext(),
       {
         searchOptions: {
@@ -234,8 +238,8 @@ describe("runAgenticRecall", () => {
             makeAdapter(
               {
                 "alice lives residence": [
-                  makeEvidence("pkb:alice-home", {
-                    source: "pkb",
+                  makeEvidence("conversations:alice-home", {
+                    source: "conversations",
                     title: "people/alice.md",
                     locator: "people/alice.md:6",
                     excerpt:
@@ -248,10 +252,9 @@ describe("runAgenticRecall", () => {
                 ],
               },
               searchCalls,
-              "pkb",
+              "conversations",
             ),
           ],
-          readPkbContextEvidence: () => [],
         },
       },
     );
@@ -263,12 +266,12 @@ describe("runAgenticRecall", () => {
     ]);
     expect(result.debug).toMatchObject({
       mode: "deterministic_fallback",
-      fallbackReason: "finish_answer_validation_failed",
-      fallbackDetail: "negative_or_incomplete_finish_with_relevant_evidence",
+      fallbackReason: "citation_validation_failed",
+      fallbackDetail: "missing_citations",
     });
     expect(result.content).toContain("Found evidence:");
     expect(result.content).toContain("Lives at Bob's parents' house in Katy");
-    expect(result.content).toContain("Searched sources: pkb.");
+    expect(result.content).toContain("Searched sources: conversations.");
   });
 
   test("seeds lead-in questions with declarative chain searches", async () => {
@@ -278,14 +281,14 @@ describe("runAgenticRecall", () => {
         answer:
           "Bob's April 24 letter followed the proud moment, the 1-in-99 hypothetical, and the direct evening disclosure.",
         confidence: "high",
-        citation_ids: ["pkb:bob-letter-chain"],
+        citation_ids: ["conversations:bob-letter-chain"],
       }),
     ]);
 
     const result = await runAgenticRecall(
       {
         query: "What led to Bob's April 24 letter?",
-        sources: ["pkb"],
+        sources: ["conversations"],
         max_results: 5,
       },
       makeContext(),
@@ -295,8 +298,8 @@ describe("runAgenticRecall", () => {
             makeAdapter(
               {
                 "bob april 24 letter": [
-                  makeEvidence("pkb:bob-letter-chain", {
-                    source: "pkb",
+                  makeEvidence("conversations:bob-letter-chain", {
+                    source: "conversations",
                     title: "archive/2026-04-24.md",
                     locator: "archive/2026-04-24.md:42",
                     excerpt:
@@ -309,10 +312,9 @@ describe("runAgenticRecall", () => {
                 ],
               },
               searchCalls,
-              "pkb",
+              "conversations",
             ),
           ],
-          readPkbContextEvidence: () => [],
         },
       },
     );
@@ -324,7 +326,7 @@ describe("runAgenticRecall", () => {
       "bob april 24 letter context reason before chain",
     ]);
     expect(result.content).toContain("1-in-99 hypothetical");
-    expect(result.content).toContain("Searched sources: pkb.");
+    expect(result.content).toContain("Searched sources: conversations.");
   });
 
   test("executes follow-up search_sources through narrowed local searches", async () => {
@@ -500,66 +502,6 @@ describe("runAgenticRecall", () => {
     ]);
   });
 
-  test("auto-inspects PKB-relative paths as workspace paths", async () => {
-    const root = makeTempDir();
-    writeWorkspaceFile(
-      root,
-      "pkb/archive/2026-04-24.md",
-      "The archive has the exact letter chain.",
-    );
-
-    const result = await runAgenticRecall(
-      {
-        query: "letter chain",
-        sources: ["pkb"],
-        max_results: 5,
-      },
-      makeContext(undefined, root),
-      {
-        searchOptions: {
-          adapters: [
-            makeAdapter(
-              {
-                "letter chain": [
-                  makeEvidence("pkb:pointer", {
-                    source: "pkb",
-                    title: "archive/2026-04-24.md",
-                    locator: "archive/2026-04-24.md:42",
-                    excerpt: "The exact note is archive/2026-04-24.md.",
-                    metadata: {
-                      retrieval: "lexical",
-                      path: "archive/2026-04-24.md",
-                    },
-                  }),
-                ],
-              },
-              [],
-              "pkb",
-            ),
-          ],
-          readPkbContextEvidence: () => [],
-        },
-      },
-    );
-
-    expect(result.debug.inspectCalls).toEqual([
-      {
-        round: 0,
-        paths: ["pkb/archive/2026-04-24.md"],
-        reason:
-          "Automatically inspect exact workspace paths surfaced by seed evidence.",
-        evidenceCount: 1,
-      },
-    ]);
-    expect(result.content).toContain(
-      "Inspected workspace paths: pkb/archive/2026-04-24.md.",
-    );
-    expect(result.evidence.map((item) => item.id)).toEqual([
-      "pkb:pointer",
-      "workspace:pkb/archive/2026-04-24.md:1:path",
-    ]);
-  });
-
   test("rejects unsafe inspect_workspace_paths requests as unresolved evidence", async () => {
     configuredProvider = makeProvider([
       toolResponse("inspect_workspace_paths", {
@@ -782,7 +724,7 @@ describe("runAgenticRecall", () => {
     const result = await runAgenticRecall(
       {
         query: "launch notes",
-        sources: ["memory", "pkb", "workspace"],
+        sources: ["memory", "conversations", "workspace"],
         max_results: 3,
       },
       makeContext(),
@@ -805,15 +747,15 @@ describe("runAgenticRecall", () => {
             makeAdapter(
               {
                 "launch notes": [
-                  makeEvidence("pkb:included", {
-                    source: "pkb",
+                  makeEvidence("conversations:included", {
+                    source: "conversations",
                     excerpt: longExcerpt,
                     score: 0.8,
                   }),
                 ],
               },
               [],
-              "pkb",
+              "conversations",
             ),
             makeAdapter(
               {
@@ -829,7 +771,6 @@ describe("runAgenticRecall", () => {
               "workspace",
             ),
           ],
-          readPkbContextEvidence: () => [],
         },
       },
     );
@@ -840,7 +781,7 @@ describe("runAgenticRecall", () => {
     }>;
     const prompt = messages[0]?.content[0]?.text ?? "";
     expect(prompt).toContain(
-      "Allowed citation_ids: memory:included, pkb:included",
+      "Allowed citation_ids: memory:included, conversations:included",
     );
     expect(prompt).not.toContain("workspace:omitted");
     expect(result.debug).toMatchObject({
@@ -905,63 +846,6 @@ describe("runAgenticRecall", () => {
     });
   });
 
-  test("keeps auto-injected context behind concrete evidence after agent searches", async () => {
-    configuredProvider = makeProvider([
-      toolResponse("search_sources", {
-        query: "follow up",
-        sources: ["workspace"],
-        reason: "Need concrete follow-up evidence.",
-      }),
-      textResponse("not a finish"),
-    ]);
-
-    const result = await runAgenticRecall(
-      {
-        query: "launch notes",
-        sources: ["pkb", "workspace"],
-        max_results: 3,
-      },
-      makeContext(),
-      {
-        searchOptions: {
-          adapters: [
-            makeAdapter({}, [], "pkb"),
-            makeAdapter(
-              {
-                "launch notes": [makeEvidence("workspace:seed")],
-                "follow up": [makeEvidence("workspace:searched")],
-              },
-              [],
-              "workspace",
-            ),
-          ],
-          readPkbContextEvidence: () => [
-            makeEvidence("pkb:auto-inject", {
-              source: "pkb",
-              title: "PKB auto-injected context",
-              locator: "pkb:auto-inject",
-              excerpt: "Always-present background context.",
-            }),
-            makeEvidence("pkb:NOW.md", {
-              source: "pkb",
-              title: "NOW.md",
-              locator: "NOW.md",
-              excerpt: "Always-present NOW context.",
-            }),
-          ],
-        },
-      },
-    );
-
-    expect(result.debug.mode).toBe("deterministic_fallback");
-    expect(result.evidence.map((item) => item.id)).toEqual([
-      "workspace:seed",
-      "workspace:searched",
-      "pkb:NOW.md",
-      "pkb:auto-inject",
-    ]);
-  });
-
   test("routes provider calls through the recall call site with temperature zero and thinking disabled", async () => {
     // `thinking: disabled` is required because the call hardcodes
     // `temperature: 0`. Anthropic 400s on `temperature` ≠ 1 whenever