@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/conversation-analysis-routes.test.ts

@@ -26,6 +26,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessages: mockGetMessages,
   createConversation: mockCreateConversation,
   addMessage: mockAddMessage,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../export/transcript-formatter.js", () => ({

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

@@ -98,12 +98,13 @@ mock.module("../skills/tool-manifest.js", () => ({
 }));
 
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  // Mirrors the real factory: no skillId in/out — ownership is recorded by
+  // the registry at `registerSkillTools(skillId, tools)` time.
   createSkillToolsFromManifest: (
     entries: SkillToolManifest["tools"],
-    skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ): Tool[] =>
     entries.map((entry) => ({
       name: entry.name,
@@ -111,28 +112,20 @@ mock.module("../tools/skills/skill-tool-factory.js", () => ({
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
       executionTarget: "sandbox" as const,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
       input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     })),
 }));
 
 mock.module("../tools/registry.js", () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
+  // Matches the new signature: `registerSkillTools(skillId, tools)`. The
+  // skillId comes from the caller (conversation-skill-tools) and is the
+  // sole source of truth for ownership.
+  registerSkillTools: (skillId: string, tools: Tool[]) => {
+    const existing = mockRegisteredTools.get(skillId) ?? [];
+    existing.push(...tools);
+    mockRegisteredTools.set(skillId, existing);
+    mockSkillRefCount.set(skillId, (mockSkillRefCount.get(skillId) ?? 0) + 1);
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
@@ -153,6 +146,23 @@ mock.module("../tools/registry.js", () => ({
     }
     return found;
   },
+  // Mirrors the registry's `ownersByName` accessor: derives the owning
+  // skillId from `mockRegisteredTools` keying so the production
+  // `getToolOwner(name)` call in `conversation-skill-tools.ts` resolves to
+  // the same shape the real registry would return.
+  getToolOwner: (
+    name: string,
+  ): { kind: "skill" | "plugin" | "mcp"; id: string } | undefined => {
+    let ownerSkillId: string | undefined;
+    for (const [skillId, tools] of mockRegisteredTools.entries()) {
+      for (const tool of tools) {
+        if (tool.name === name) ownerSkillId = skillId;
+      }
+    }
+    return ownerSkillId === undefined
+      ? undefined
+      : { kind: "skill", id: ownerSkillId };
+  },
   getSkillToolNames: () => {
     const names: string[] = [];
     for (const tools of mockRegisteredTools.values()) {

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

@@ -92,6 +92,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: async () => ({ id: "persisted-1" }),
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-attention-store.test.ts

@@ -147,6 +147,107 @@ describe("conversation-attention-store", () => {
       const state = states.get("conv-1")!;
       expect(state.latestAssistantMessageId).toBe("msg-1");
     });
+
+    test("returns true when creating new attention state (no prior state)", () => {
+      ensureConversation("conv-1");
+      const result = projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        messageAt: 1000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("returns true when advancing cursor past seen position (seen→unseen)", () => {
+      ensureConversation("conv-1");
+      projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        messageAt: 1000,
+      });
+      recordConversationSeenSignal({
+        conversationId: "conv-1",
+        sourceChannel: "vellum",
+        signalType: "macos_conversation_opened",
+        confidence: "explicit",
+        source: "test",
+      });
+      const result = projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-2",
+        messageAt: 2000,
+      });
+      expect(result).toBe(true);
+    });
+
+    test("returns false when conversation is already unseen", () => {
+      ensureConversation("conv-1");
+      projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        messageAt: 1000,
+      });
+      const result = projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-2",
+        messageAt: 2000,
+      });
+      expect(result).toBe(false);
+    });
+
+    test("returns false when cursor does not advance (older message)", () => {
+      ensureConversation("conv-1");
+      projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-2",
+        messageAt: 2000,
+      });
+      const result = projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        messageAt: 1000,
+      });
+      expect(result).toBe(false);
+    });
+
+    test("returns false when cursor does not advance (equal timestamp)", () => {
+      ensureConversation("conv-1");
+      projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        messageAt: 1000,
+      });
+      const result = projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1-dup",
+        messageAt: 1000,
+      });
+      expect(result).toBe(false);
+    });
+
+    test("returns true when row exists with null latestAssistantMessageAt (seen signal before first assistant msg)", () => {
+      ensureConversation("conv-1");
+      // Simulate: user opens conversation before any assistant message,
+      // which calls recordConversationSeenSignal and creates a state row
+      // with latestAssistantMessageAt = null.
+      recordConversationSeenSignal({
+        conversationId: "conv-1",
+        sourceChannel: "vellum",
+        signalType: "macos_conversation_opened",
+        confidence: "explicit",
+        source: "test",
+      });
+      const states = getAttentionStateByConversationIds(["conv-1"]);
+      expect(states.get("conv-1")!.latestAssistantMessageAt).toBeNull();
+
+      // First assistant message should transition to unseen
+      const result = projectAssistantMessage({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        messageAt: 1000,
+      });
+      expect(result).toBe(true);
+    });
   });
 
   // ── recordConversationSeenSignal ────────────────────────────────

package/src/__tests__/conversation-attention-telegram.test.ts

@@ -32,18 +32,19 @@ mock.module("../daemon/handlers/shared.js", () => ({
 import { eq } from "drizzle-orm";
 
 import { upsertContact } from "../contacts/contact-store.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryChannels from "../memory/delivery-channels.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { attachments, conversationAttentionEvents } from "../memory/schema.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 
 initializeDb();
 
 afterAll(() => {
-  resetDb();
+  resetDbForTesting();
 });
 
 // ---------------------------------------------------------------------------

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

@@ -142,6 +142,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: `msg-${Date.now()}` }),
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

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

@@ -14,6 +14,7 @@ import {
   classifyConversationError,
   isUserCancellation,
 } from "../daemon/conversation-error.js";
+import { ConnectionResolutionError } from "../providers/connection-resolution.js";
 import {
   type AbortReasonKind,
   createAbortReason,
@@ -978,3 +979,32 @@ describe("budgetYieldUnrecoveredClassification", () => {
     expect(envelope.userMessage).toBe(classified.userMessage);
   });
 });
+
+describe("ConnectionResolutionError classification", () => {
+  const errCtx: ErrorContext = { phase: "agent_loop" };
+
+  it("classifies provider_mismatch as PROVIDER_NOT_CONFIGURED with user-friendly message", () => {
+    const err = new ConnectionResolutionError(
+      "anthropic-managed",
+      "provider_mismatch",
+      'provider_connection "anthropic-managed" has provider="anthropic" but resolving profile declared provider="openai"',
+    );
+    const result = classifyConversationError(err, errCtx);
+    expect(result.code).toBe("PROVIDER_NOT_CONFIGURED");
+    expect(result.userMessage).toContain("No compatible provider connection");
+    expect(result.userMessage).toContain("Settings");
+    expect(result.userMessage).not.toContain("provider_connection");
+    expect(result.connectionName).toBe("anthropic-managed");
+  });
+
+  it("classifies not_found as PROVIDER_NOT_CONFIGURED", () => {
+    const err = new ConnectionResolutionError(
+      "deleted-connection",
+      "not_found",
+      'provider_connection "deleted-connection" not found in DB',
+    );
+    const result = classifyConversationError(err, errCtx);
+    expect(result.code).toBe("PROVIDER_NOT_CONFIGURED");
+    expect(result.userMessage).not.toContain("not found in DB");
+  });
+});

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

@@ -214,6 +214,40 @@ describe("forkConversation", () => {
     ]);
   });
 
+  test("pinned fork through a (createdAt, id) cutoff matches the cursor slice for same-timestamp rows", () => {
+    // Regression for the memory-retrospective cutoff/fork divergence: the job
+    // picks its cutoff from `getMessagesAfter`, which orders by `(createdAt,
+    // id)`. `forkConversation` must slice on the same order so same-millisecond
+    // siblings aren't skipped forever or reprocessed. Insert rows whose
+    // insertion order is the reverse of their `(createdAt, id)` order to expose
+    // the divergence: a `createdAt`-only slice would pick the wrong prefix.
+    const source = createConversation("Same-timestamp cutoff thread");
+    const db = getDb();
+    const createdAt = Date.now();
+    // Insert d, c, b, a so SQLite's createdAt-only tie order (≈ rowid /
+    // insertion order) is the opposite of the (createdAt, id) cursor order
+    // (a, b, c, d). All are plain user rows so no display-turn extension fires.
+    for (const id of ["msg-d", "msg-c", "msg-b", "msg-a"]) {
+      db.run(
+        `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('${id}', '${source.id}', 'user', '${id}', ${createdAt})`,
+      );
+    }
+
+    // Cutoff = "msg-c": the cursor treats {msg-a, msg-b, msg-c} as processed
+    // and {msg-d} as still-after-the-cutoff. The fork must contain exactly the
+    // first three in `(createdAt, id)` order.
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: "msg-c",
+    });
+
+    expect(getMessages(fork.id).map((message) => message.content)).toEqual([
+      "msg-a",
+      "msg-b",
+      "msg-c",
+    ]);
+  });
+
   test("advances fork boundary through consecutive assistant rows after the requested message", async () => {
     // When the read-path merges consecutive assistant DB rows into a single
     // display row, the client only addresses the anchor id. Forking through
@@ -273,9 +307,15 @@ describe("forkConversation", () => {
     // between — otherwise the fork loses tool_use ↔ tool_result pairing
     // and produces an invalid LLM history.
     const source = createConversation("Tool-result gap thread");
-    await addMessage(source.id, "user", "Find the latest sales numbers", undefined, {
-      skipIndexing: true,
-    });
+    await addMessage(
+      source.id,
+      "user",
+      "Find the latest sales numbers",
+      undefined,
+      {
+        skipIndexing: true,
+      },
+    );
     const anchor = await addMessage(
       source.id,
       "assistant",
@@ -527,13 +567,34 @@ describe("forkConversation", () => {
       },
       { skipIndexing: true },
     );
-    await addMessage(source.id, "assistant", "Reply 1", undefined, {
-      skipIndexing: true,
-    });
-    await addMessage(source.id, "user", "Tail turn", undefined, {
+    const reply1 = await addMessage(
+      source.id,
+      "assistant",
+      "Reply 1",
+      undefined,
+      {
+        skipIndexing: true,
+      },
+    );
+    const tail = await addMessage(source.id, "user", "Tail turn", undefined, {
       skipIndexing: true,
     });
-    const compactedAt = Date.now();
+    // Pin strictly-increasing timestamps so the pinned fork boundary is
+    // unambiguous. `addMessage` stamps `Date.now()`, and these three rows can
+    // land in the same millisecond; under the `(createdAt, id)` tie-break the
+    // pinned fork uses, that would let `m1`'s slice reorder relative to its
+    // siblings. Distinct timestamps keep this test focused on its intent —
+    // pre-compaction metadata + compaction-state inheritance.
+    const db = getDb();
+    const base = Date.now();
+    db.run(`UPDATE messages SET created_at = ${base} WHERE id = '${m1.id}'`);
+    db.run(
+      `UPDATE messages SET created_at = ${base + 1} WHERE id = '${reply1.id}'`,
+    );
+    db.run(
+      `UPDATE messages SET created_at = ${base + 2} WHERE id = '${tail.id}'`,
+    );
+    const compactedAt = base + 3;
     getDb()
       .update(conversations)
       .set({

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

@@ -45,11 +45,12 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { addMessage, createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { getPolicy } from "../runtime/auth/route-policy.js";
 import { mintToken } from "../runtime/auth/token-service.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 
 initializeDb();
@@ -98,7 +99,7 @@ describe("POST /v1/conversations/fork", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("returns the same conversation summary shape as GET /v1/conversations/:id", async () => {

package/src/__tests__/conversation-history-web-search.test.ts

@@ -50,6 +50,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   relinkAttachments: () => 0,
   deleteLastExchange: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-inference-profile-list.test.ts

@@ -42,9 +42,10 @@ import {
   createConversation,
   setConversationInferenceProfile,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -65,7 +66,7 @@ describe("conversation HTTP responses include inferenceProfile", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("GET /v1/conversations includes inferenceProfile for pinned conversations and omits it when unset", async () => {

package/src/__tests__/conversation-inference-profile-route.test.ts

@@ -30,11 +30,12 @@ import {
   createConversation,
   getConversation,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -57,7 +58,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
   });
 
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

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

@@ -102,6 +102,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-list-source.test.ts

@@ -44,9 +44,10 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -68,7 +69,7 @@ describe("GET /v1/conversations includes source discriminator", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("returns source for every listed conversation", async () => {

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -104,6 +104,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -535,7 +536,7 @@ describe("loadFromDb history repair", () => {
       trustClass: "guardian",
       sourceChannel: "telegram",
     });
-    await conversation.persistUserMessage("Guardian follow-up", []);
+    await conversation.persistUserMessage({ content: "Guardian follow-up" });
     const messagesAfterPersist = conversation.getMessages();
 
     expect(messagesAfterPersist).toHaveLength(5);

package/src/__tests__/conversation-load-history-stripped.test.ts

@@ -87,6 +87,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationHistoryStrippedAt: () => {},
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

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

@@ -67,6 +67,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   createConversation: createConversationMock,
   addMessage: addMessageMock,
   getConversation: getConversationMock,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 /** Simulated bindings for external-conversation-store mock. */
@@ -122,6 +123,11 @@ function makeSignal(
       isAsyncBackground: true,
       visibleInSourceNow: false,
     },
+    // Most existing pairing tests pre-date the passive-by-default gate and
+    // exercise the conversation-creation path. Default to the opt-in flag so
+    // they continue to assert creation semantics; the dedicated passive-gate
+    // test below explicitly omits it to cover the new default.
+    requiresConversation: true,
     ...overrides,
   };
 }
@@ -815,6 +821,53 @@ describe("pairDeliveryWithConversation", () => {
     expect(getBindingByChannelChatMock).not.toHaveBeenCalled();
   });
 
+  // ── Passive default: vellum no-creates without opt-in ─────────────
+
+  test("passive vellum signal does not create a conversation or message", async () => {
+    const signal = makeSignal({ requiresConversation: undefined });
+    const copy = makeCopy();
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+    );
+
+    expect(result.conversationId).toBeNull();
+    expect(result.messageId).toBeNull();
+    expect(result.strategy).toBe("start_new_conversation");
+    expect(result.createdNewConversation).toBe(false);
+    expect(result.conversationFallbackUsed).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+
+  test("passive vellum signal still honors explicit reuse_existing action", async () => {
+    mockExistingConversations["conv-explicit-passive"] = {
+      id: "conv-explicit-passive",
+      source: "notification",
+      title: "Existing",
+    };
+    const signal = makeSignal({ requiresConversation: undefined });
+    const copy = makeCopy();
+    const conversationAction: ConversationAction = {
+      action: "reuse_existing",
+      conversationId: "conv-explicit-passive",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+      { conversationAction },
+    );
+
+    expect(result.conversationId).toBe("conv-explicit-passive");
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).toHaveBeenCalledTimes(1);
+  });
+
   // ── conversationMetadata.conversationType override ─────────────────
 
   test("uses conversationMetadata.conversationType when set, overriding channel strategy", async () => {