@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/__tests__/contact-store-interaction-info.test.ts

@@ -0,0 +1,156 @@
+/**
+ * INFO telemetry (interactionCount/lastInteraction/lastSeenAt) is local, not
+ * ACL: the gateway's handle-inbound mirror writes it to the assistant DB, and
+ * model-facing turn context reads it back. These tests assert the daemon-native
+ * read paths (getContact / searchContacts) re-hydrate and aggregate it.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  findContactInfoById,
+  getContact,
+  searchContacts,
+} from "../contacts/contact-store.js";
+import { getSqlite } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+
+await initializeDb();
+
+function resetContactTables(): void {
+  const sqlite = getSqlite();
+  sqlite.run("DELETE FROM contact_channels");
+  sqlite.run("DELETE FROM contacts");
+}
+
+function insertContact(id: string, displayName: string): void {
+  const now = Date.now();
+  getSqlite().run(
+    "INSERT INTO contacts (id, display_name, role, contact_type, user_file, created_at, updated_at) VALUES (?, ?, 'contact', 'human', ?, ?, ?)",
+    [id, displayName, `${id}.md`, now, now],
+  );
+}
+
+function insertChannel(params: {
+  id: string;
+  contactId: string;
+  type: string;
+  address: string;
+  interactionCount: number;
+  lastInteraction: number | null;
+  lastSeenAt?: number | null;
+}): void {
+  const now = Date.now();
+  getSqlite().run(
+    "INSERT INTO contact_channels (id, contact_id, type, address, is_primary, interaction_count, last_interaction, last_seen_at, created_at, updated_at) VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?)",
+    [
+      params.id,
+      params.contactId,
+      params.type,
+      params.address,
+      params.interactionCount,
+      params.lastInteraction,
+      params.lastSeenAt ?? null,
+      now,
+      now,
+    ],
+  );
+}
+
+describe("contact interaction INFO aggregation", () => {
+  beforeEach(() => {
+    resetContactTables();
+  });
+
+  test("getContact sums interaction_count and takes the latest last_interaction across channels", () => {
+    insertContact("ct_1", "Alice");
+    insertChannel({
+      id: "ch_a",
+      contactId: "ct_1",
+      type: "phone",
+      address: "+15550100",
+      interactionCount: 3,
+      lastInteraction: 1900,
+      lastSeenAt: 1850,
+    });
+    insertChannel({
+      id: "ch_b",
+      contactId: "ct_1",
+      type: "email",
+      address: "alice@example.com",
+      interactionCount: 4,
+      lastInteraction: 2100,
+      lastSeenAt: 2050,
+    });
+
+    const contact = getContact("ct_1");
+    expect(contact).not.toBeNull();
+    expect(contact!.interactionCount).toBe(7);
+    expect(contact!.lastInteraction).toBe(2100);
+
+    // Per-channel INFO is hydrated too.
+    const phone = contact!.channels.find((c) => c.type === "phone");
+    expect(phone?.interactionCount).toBe(3);
+    expect(phone?.lastInteraction).toBe(1900);
+    expect(phone?.lastSeenAt).toBe(1850);
+  });
+
+  test("findContactInfoById surfaces the real interaction count", () => {
+    insertContact("ct_2", "Bob");
+    insertChannel({
+      id: "ch_c",
+      contactId: "ct_2",
+      type: "phone",
+      address: "+15550200",
+      interactionCount: 5,
+      lastInteraction: 1000,
+    });
+
+    const info = findContactInfoById("ct_2");
+    expect(info?.interactionCount).toBe(5);
+  });
+
+  test("lastInteraction is null when no channel has interacted", () => {
+    insertContact("ct_3", "Carol");
+    insertChannel({
+      id: "ch_d",
+      contactId: "ct_3",
+      type: "phone",
+      address: "+15550300",
+      interactionCount: 0,
+      lastInteraction: null,
+    });
+
+    const contact = getContact("ct_3");
+    expect(contact!.interactionCount).toBe(0);
+    expect(contact!.lastInteraction).toBeNull();
+  });
+
+  test("filtered searchContacts carries channel INFO fields", () => {
+    insertContact("ct_4", "Dana");
+    insertChannel({
+      id: "ch_e",
+      contactId: "ct_4",
+      type: "phone",
+      address: "+15550400",
+      interactionCount: 9,
+      lastInteraction: 3000,
+      lastSeenAt: 2900,
+    });
+
+    const results = searchContacts({ query: "Dana", limit: 10 });
+    expect(results).toHaveLength(1);
+    expect(results[0].interactionCount).toBe(9);
+    expect(results[0].lastInteraction).toBe(3000);
+    const ch = results[0].channels[0];
+    expect(ch.interactionCount).toBe(9);
+    expect(ch.lastSeenAt).toBe(2900);
+  });
+});

package/src/__tests__/contact-store-user-file.test.ts

@@ -66,11 +66,10 @@ describe("upsertContact user_file selection", () => {
     resetContactTables();
   });
 
-  test("reuses an existing sibling's userFile when principalId matches", () => {
+  test("assigns a fresh slug per contact; principalId is gateway-owned and no longer groups siblings locally", () => {
     const primary = upsertContact({
       displayName: "Chris",
       role: "guardian",
-      principalId: "principal-abc",
       channels: [
         {
           type: "vellum",
@@ -80,12 +79,12 @@ describe("upsertContact user_file selection", () => {
     });
     expect(primary.userFile).toBe("chris.md");
 
-    // Second contact for the same principal on Slack — must inherit the
-    // first contact's userFile, NOT auto-increment to chris-2.md.
+    // A second contact with the same display name no longer inherits the
+    // first's userFile via a local principal lookup — it gets a fresh
+    // (collision-incremented) slug. Sibling grouping is owned by the gateway.
     const slack = upsertContact({
       displayName: "chris",
       role: "guardian",
-      principalId: "principal-abc",
       channels: [
         {
           type: "slack",
@@ -94,15 +93,14 @@ describe("upsertContact user_file selection", () => {
         },
       ],
     });
-    expect(slack.userFile).toBe("chris.md");
+    expect(slack.userFile).toBe("chris-2.md");
     expect(slack.id).not.toBe(primary.id);
   });
 
-  test("falls back to generateUserFileSlug when principalId has no existing sibling", () => {
+  test("generates a slug from the display name for a brand-new contact", () => {
     const contact = upsertContact({
       displayName: "Alice",
       role: "contact",
-      principalId: "principal-alone",
       channels: [
         {
           type: "slack",
@@ -141,7 +139,7 @@ describe("upsertContact user_file selection", () => {
     expect(second.userFile).toBe("bob-2.md");
   });
 
-  test("ignores a sibling whose userFile is null and generates a new slug", () => {
+  test("a null-userFile contact does not block a fresh slug for a new contact", () => {
     insertContact({
       id: "seed-null",
       displayName: "legacy",
@@ -154,7 +152,6 @@ describe("upsertContact user_file selection", () => {
     const contact = upsertContact({
       displayName: "Legacy",
       role: "guardian",
-      principalId: "principal-null",
       channels: [
         {
           type: "phone",

package/src/__tests__/contacts-relay-reads.test.ts

@@ -3,8 +3,9 @@
  *
  * handleListContacts (non-search) and handleGetContact relay to the gateway
  * via `ipcCallPersistent`. On the happy path they serve gateway-sourced data
- * and do NOT read the assistant DB. On IPC failure they fall back to the
- * assistant-DB read and log a warning. getContact still 404s for unknown ids.
+ * and do NOT read the assistant DB. On IPC failure they FAIL CLOSED — the relay
+ * error propagates rather than falling back to the assistant DB. getContact
+ * surfaces a clean gateway not-found as a 404.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -62,19 +63,18 @@ const realContactStore = await import("../contacts/contact-store.js");
 // contactType is filtered in SQL (before the limit) rather than relayed.
 const listContactsArgs: Array<{
   limit?: number;
-  role?: string;
   contactType?: string;
 }> = [];
 mock.module("../contacts/contact-store.js", () => ({
   ...realContactStore,
-  listContacts: (limit?: number, role?: string, contactType?: string) => {
+  listContacts: (limit?: number, contactType?: string) => {
     localCalls.push("listContacts");
-    listContactsArgs.push({ limit, role, contactType });
+    listContactsArgs.push({ limit, contactType });
     return [
       {
         id: "local-1",
         displayName: "Local Contact",
-        role: role ?? "contact",
+        role: "contact",
         contactType: contactType ?? "human",
         interactionCount: 0,
         channels: [],
@@ -213,16 +213,15 @@ describe("handleListContacts relay", () => {
     expect(result.contacts[0].displayName).toBe("Your Guardian");
   });
 
-  test("falls back to the assistant DB on IPC failure", async () => {
+  test("fails closed on IPC failure (no assistant-DB fallback)", async () => {
     ipcStub = () => {
       throw new Error("gateway down");
     };
 
-    const result = await handleListContacts({});
+    await expect(handleListContacts({})).rejects.toThrow("gateway down");
 
     expect(ipcCalls.map((c) => c.method)).toEqual(["contacts_list_rich"]);
-    expect(localCalls).toContain("listContacts");
-    expect(result.contacts[0].id).toBe("local-1");
+    expect(localCalls).toEqual([]);
   });
 
   test("search params stay daemon-native and log the boundary note", async () => {
@@ -248,20 +247,18 @@ describe("handleListContacts relay", () => {
     // contactType + limit are pushed into the SQL-filtered daemon read (the
     // daemon-native listContacts filters contactType BEFORE applying limit).
     expect(listContactsArgs).toEqual([
-      { limit: 50, role: undefined, contactType: "assistant" },
+      { limit: 50, contactType: "assistant" },
     ]);
     expect(result.contacts[0].id).toBe("local-1");
     expect(result.contacts[0].contactType).toBe("assistant");
     expect(debugLogs.some((m) => m.includes("daemon-native"))).toBe(true);
   });
 
-  test("contactType + role both flow into the daemon-native read", async () => {
+  test("contactType filters daemon-native; role is gateway-owned and no longer a local predicate", async () => {
     await handleListContacts({ contactType: "human", role: "guardian" });
 
     expect(ipcCalls).toEqual([]);
-    expect(listContactsArgs).toEqual([
-      { limit: 50, role: "guardian", contactType: "human" },
-    ]);
+    expect(listContactsArgs).toEqual([{ limit: 50, contactType: "human" }]);
   });
 });
 
@@ -384,26 +381,24 @@ describe("handleGetContact relay", () => {
     expect(localCalls).toEqual([]);
   });
 
-  test("falls back to the assistant DB on IPC transport failure", async () => {
+  test("fails closed on IPC transport failure (no assistant-DB fallback)", async () => {
     ipcStub = () => {
       throw new Error("gateway down");
     };
 
-    const result = await handleGetContact("gw-1");
+    await expect(handleGetContact("gw-1")).rejects.toThrow("gateway down");
 
     expect(ipcCalls.map((c) => c.method)).toEqual(["contacts_get_rich"]);
-    expect(localCalls).toContain("getContact");
-    expect(result.contact.id).toBe("gw-1");
+    expect(localCalls).toEqual([]);
   });
 
-  test("fallback path still 404s for unknown ids", async () => {
-    ipcStub = () => {
-      throw new Error("gateway down");
-    };
+  test("clean gateway not-found surfaces as a 404 for unknown ids", async () => {
+    ipcStub = () => null;
 
     await expect(handleGetContact("missing")).rejects.toThrow(
       'Contact "missing" not found',
     );
-    expect(localCalls).toContain("getContact");
+    expect(ipcCalls.map((c) => c.method)).toEqual(["contacts_get_rich"]);
+    expect(localCalls).toEqual([]);
   });
 });

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

@@ -63,8 +63,6 @@ describe("guardian persona seeding and trust-cache invariants", () => {
       externalUserId: "Bob",
       externalChatId: "chat-bob",
       displayName: "Bob",
-      role: "contact",
-      status: "active",
     });
 
     expect(result).not.toBeNull();

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

@@ -112,6 +112,8 @@ let reservedRowContent: Map<string, string> = new Map();
 let reserveCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},

package/src/__tests__/conversation-agent-loop-disk-pressure.test.ts

@@ -87,6 +87,8 @@ mock.module("../daemon/disk-pressure-guard.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getConversation: () => ({
     id: "conv-123",
     conversationType: "background",

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

@@ -147,6 +147,8 @@ let mockConversationRow: {
 };
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -257,6 +257,8 @@ mock.module("../plugins/defaults/compaction/overflow-policy.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},

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

@@ -10,8 +10,14 @@ import {
 } from "bun:test";
 
 import type { LoopToolExecutor } from "../agent/loop.js";
+import {
+  queueConversationNotice,
+  resetConversationNoticesForTests,
+} from "../daemon/conversation-notices.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import { registerPlugin } from "../plugins/registry.js";
 import type { Message, Provider, ToolDefinition } from "../providers/types.js";
 import { ContextOverflowError } from "../providers/types.js";
 
@@ -273,6 +279,8 @@ const deleteMessageByIdMock = mock(() => ({
 const reserveMessageMock = mock(async () => ({ id: "msg-reserve" }));
 const updateMessageContentMock = mock(() => {});
 mock.module("../memory/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationUsage: () => {},
   updateMessageMetadata: updateMessageMetadataMock,
@@ -700,6 +708,7 @@ function makeCtx(
       mockConversationRow?.slackContextCompactionWatermarkTs ?? null,
     lastNotifiedInferenceProfile:
       mockConversationRow?.lastNotifiedInferenceProfile ?? null,
+    processingStartedAt: mockConversationRow?.processingStartedAt ?? null,
 
     memoryPolicy: { scopeId: "default", includeDefaultFallback: true },
 
@@ -864,7 +873,14 @@ beforeEach(() => {
   indexMessageNowMock.mockClear();
   projectAssistantMessageMock.mockClear();
   publishSyncInvalidationMock.mockClear();
+  resolveAssistantAttachmentsMock.mockClear();
+  resolveAssistantAttachmentsMock.mockImplementation(async () => ({
+    assistantAttachments: [],
+    emittedAttachments: [],
+    directiveWarnings: [],
+  }));
   mockMessageById = null;
+  resetConversationNoticesForTests();
   // The compaction pipeline runs through the plugin registry; reset and
   // re-register every default so it dispatches to middleware backed by the
   // mocked collaborators these tests install (`syncMessageToDisk`, etc.)
@@ -873,6 +889,120 @@ beforeEach(() => {
 });
 
 describe("session-agent-loop", () => {
+  describe("user-prompt-submit hook failures", () => {
+    test("logs and continues with prior hook mutations", async () => {
+      registerPlugin({
+        manifest: {
+          name: "test-user-prompt-rewrite",
+          version: "1.0.0",
+        },
+        hooks: {
+          "user-prompt-submit": async (_ctx: UserPromptSubmitContext) => ({
+            latestMessages: [
+              {
+                role: "user" as const,
+                content: [{ type: "text" as const, text: "rewritten prompt" }],
+              },
+            ],
+          }),
+        },
+      });
+      registerPlugin({
+        manifest: {
+          name: "test-user-prompt-throw",
+          version: "1.0.0",
+        },
+        hooks: {
+          "user-prompt-submit": async () => {
+            throw new Error("simulated hook failure");
+          },
+        },
+      });
+
+      const events: ServerMessage[] = [];
+      const ctx = makeCtx({ providerResponses: [textResponse("ok")] });
+      const runSpy = spyOn(ctx.agentLoop, "run");
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(runSpy).toHaveBeenCalledTimes(1);
+      const call = runSpy.mock.calls[0]?.[0] as
+        | { messages: Message[] }
+        | undefined;
+      expect(call?.messages[0]?.content).toEqual([
+        { type: "text", text: "rewritten prompt" },
+      ]);
+      expect(
+        events.find((event) => event.type === "conversation_error"),
+      ).toBeUndefined();
+      expect(
+        events.find((event) => event.type === "message_complete"),
+      ).toBeDefined();
+    });
+  });
+
+  describe("conversation notices", () => {
+    test("emits queued billing notices after a successful turn", async () => {
+      const events: ServerMessage[] = [];
+      const ctx = makeCtx({ providerResponses: [textResponse("ok")] });
+      queueConversationNotice(ctx.conversationId, "memory-v3-test", {
+        source: "memory_v3",
+        code: "PROVIDER_BILLING",
+        userMessage: "You've run out of credits.",
+        errorCategory: "credits_exhausted",
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(
+        events.find((event) => event.type === "conversation_error"),
+      ).toBeUndefined();
+      const messageCompleteIndex = events.findIndex(
+        (event) => event.type === "message_complete",
+      );
+      const conversationNoticeIndex = events.findIndex(
+        (event) => event.type === "conversation_notice",
+      );
+
+      expect(messageCompleteIndex).toBeGreaterThanOrEqual(0);
+      expect(conversationNoticeIndex).toBeGreaterThan(messageCompleteIndex);
+      expect(events[conversationNoticeIndex]).toEqual({
+        type: "conversation_notice",
+        conversationId: "test-conv",
+        source: "memory_v3",
+        code: "PROVIDER_BILLING",
+        userMessage: "You've run out of credits.",
+        errorCategory: "credits_exhausted",
+      });
+    });
+
+    test("clears queued notices when post-loop success work fails", async () => {
+      resolveAssistantAttachmentsMock.mockImplementation(async () => {
+        throw new Error("attachment resolution failed");
+      });
+      const events: ServerMessage[] = [];
+      const ctx = makeCtx({ providerResponses: [textResponse("ok")] });
+      queueConversationNotice(ctx.conversationId, "memory-v3-test", {
+        source: "memory_v3",
+        code: "PROVIDER_BILLING",
+        userMessage: "You've run out of credits.",
+        errorCategory: "credits_exhausted",
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      expect(
+        events.find((event) => event.type === "conversation_notice"),
+      ).toBeUndefined();
+      expect(
+        events.find((event) => event.type === "message_complete"),
+      ).toBeUndefined();
+      expect(
+        events.find((event) => event.type === "conversation_error"),
+      ).toBeDefined();
+    });
+  });
+
   describe("timezone turn context", () => {
     test("passes ctx.clientTimezone and ui.detectedTimezone into timezone resolution", async () => {
       mockUiConfig = {
@@ -1705,6 +1835,10 @@ describe("session-agent-loop", () => {
       expect(ctx.abortController).toBeNull();
       expect(ctx.currentRequestId).toBeUndefined();
       expect(ctx.commandIntent).toBeUndefined();
+      // Turn-scoped interactivity is stamped during the run and must be cleared
+      // so paths that bypass this loop (e.g. opportunity wakes) don't inherit a
+      // stale value instead of falling back to live client state.
+      expect(ctx.currentTurnIsNonInteractive).toBeUndefined();
     });
 
     test("clears state and surfaces a processing error when the provider call fails", async () => {

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

@@ -22,6 +22,8 @@ mock.module("../memory/conversation-key-store.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   getConversation: mockGetConversation,
   getMessages: mockGetMessages,
   createConversation: mockCreateConversation,

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

@@ -76,6 +76,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
   updateConversationTitle: () => {},

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

@@ -31,7 +31,6 @@ mock.module("../daemon/handlers/shared.js", () => ({
 
 import { eq } from "drizzle-orm";
 
-import { upsertContact } from "../contacts/contact-store.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryChannels from "../memory/delivery-channels.js";
@@ -39,7 +38,10 @@ 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";
+import {
+  handleChannelInbound,
+  seedContactChannel,
+} from "./helpers/channel-test-adapter.js";
 
 await initializeDb();
 
@@ -69,16 +71,12 @@ function resetTables(): void {
 }
 
 function ensureTestContact(): void {
-  upsertContact({
+  seedContactChannel({
+    sourceChannel: "telegram",
+    externalUserId: "telegram-user-default",
     displayName: "Test User",
-    channels: [
-      {
-        type: "telegram",
-        address: "telegram-user-default",
-        status: "active",
-        policy: "allow",
-      },
-    ],
+    status: "active",
+    policy: "allow",
   });
 }
 

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

@@ -112,6 +112,8 @@ mock.module("../security/secret-allowlist.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
+    setConversationProcessingStartedAt: () => {},
+    isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},