@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/conversation-process-callsite.test.ts

@@ -20,15 +20,11 @@ import type { Message, ProviderResponse } from "../providers/types.js";
 const captured: {
   callSite?: string;
   constructorMaxTokens?: unknown;
-  resolvedMaxTokens?: unknown;
-  resolvedHasMaxTokens?: boolean;
 } = {};
 
 function clearCaptured(): void {
   captured.callSite = undefined;
   captured.constructorMaxTokens = undefined;
-  captured.resolvedMaxTokens = undefined;
-  captured.resolvedHasMaxTokens = undefined;
 }
 
 mock.module("../util/logger.js", () => ({
@@ -207,14 +203,8 @@ mock.module("../agent/loop.js", () => ({
       provider?: unknown;
       systemPrompt?: string;
       config?: Record<string, unknown>;
-      resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>;
     }) {
       captured.constructorMaxTokens = options?.config?.maxTokens;
-      const resolved = options?.resolveSystemPrompt?.([]);
-      captured.resolvedMaxTokens = resolved?.maxTokens;
-      captured.resolvedHasMaxTokens =
-        resolved !== undefined &&
-        Object.prototype.hasOwnProperty.call(resolved, "maxTokens");
     }
     getToolTokenBudget() {
       return 0;
@@ -246,6 +236,12 @@ mock.module("../agent/loop.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     constructor() {}
     updateConfig() {}
     shouldCompact() {
@@ -375,8 +371,6 @@ describe("processMessage callSite threading", () => {
     await getOrCreateConversation("conv-store-default");
 
     expect(captured.constructorMaxTokens).toBeUndefined();
-    expect(captured.resolvedMaxTokens).toBeUndefined();
-    expect(captured.resolvedHasMaxTokens).toBe(false);
   });
 
   test("preserves explicit maxResponseTokens at conversation creation", async () => {
@@ -397,8 +391,6 @@ describe("processMessage callSite threading", () => {
     });
 
     expect(captured.constructorMaxTokens).toBe(1234);
-    expect(captured.resolvedMaxTokens).toBe(1234);
-    expect(captured.resolvedHasMaxTokens).toBe(true);
   });
 
   test("applies clientTimezone in the create and reuse transport metadata path", async () => {

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -147,6 +147,12 @@ mock.module("../memory/retriever.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     conversationId: string | undefined;
     constructor(options?: { conversationId?: string }) {
       this.conversationId = options?.conversationId;

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

@@ -259,6 +259,12 @@ mock.module("../memory/retriever.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     constructor() {}
     updateConfig() {}
     shouldCompact() {
@@ -2905,3 +2911,92 @@ describe("MessageQueue byte budget", () => {
     ).toBe(false);
   });
 });
+
+describe("subagent notification user_message_echo suppression", () => {
+  beforeEach(() => {
+    pendingRuns = [];
+    capturedAddMessages.length = 0;
+  });
+
+  test("drained subagent-notification message persists and wakes the agent but emits no user_message_echo", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events1: ServerMessage[] = [];
+    const eventsNotif: ServerMessage[] = [];
+
+    // Occupy the conversation so the injected notification queues.
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+    expect(conversation.isProcessing()).toBe(true);
+
+    // A daemon-injected subagent completion notification carries
+    // `subagentNotification` metadata.
+    conversation.enqueueMessage({
+      content: '[Subagent "research" completed]',
+      onEvent: (e) => eventsNotif.push(e),
+      requestId: "req-notif",
+      metadata: {
+        subagentNotification: {
+          subagentId: "sub-1",
+          label: "research",
+          status: "completed",
+        },
+      },
+    });
+
+    // Resolving the first run drains the queued notification.
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    // It is still persisted (so the orchestrator LLM sees it in the transcript)
+    // and still wakes the agent (a run was created for the drained message)...
+    expect(
+      capturedAddMessages.some((m) => m.content.includes("Subagent")),
+    ).toBe(true);
+    expect(pendingRuns.length).toBe(2);
+    // ...but no user_message_echo is broadcast, so the client never renders it
+    // as a live user bubble.
+    expect(eventsNotif.some((e) => e.type === "user_message_echo")).toBe(false);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
+  test("drained ordinary message still emits user_message_echo", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events1: ServerMessage[] = [];
+    const eventsNormal: ServerMessage[] = [];
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "ordinary message",
+      onEvent: (e) => eventsNormal.push(e),
+      requestId: "req-normal",
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(eventsNormal.some((e) => e.type === "user_message_echo")).toBe(true);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+});

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -90,7 +90,7 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-initializeDb();
+await initializeDb();
 
 const conversationInstances = new Map<string, Conversation>();
 

package/src/__tests__/conversation-routes-guardian-reply.test.ts

@@ -104,6 +104,18 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
   }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-contact",
+      principalId: "test-user",
+      address: "test-user",
+      status: "active",
+    },
+  ],
+}));
+
 import type { AuthContext } from "../runtime/auth/types.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 import { callHandler } from "./helpers/call-route-handler.js";

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -190,6 +190,18 @@ mock.module("../runtime/trust-context-resolver.js", () => ({
   }),
 }));
 
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-contact",
+      principalId: "test-user",
+      address: "test-user",
+      status: "active",
+    },
+  ],
+}));
+
 const ipcCallMock = mock(
   async (): Promise<Record<string, unknown> | undefined> => ({ ok: true }),
 );

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -33,6 +33,40 @@ mock.module("../config/loader.js", () => ({
   },
 }));
 
+// `resolveTurnInboundActorContext` reads INFO (contact notes / interaction
+// count) via a local contactId join. Stub the join so the actor-context tests
+// can stage it without standing up the contacts schema.
+const realContactStoreForAssemblyTest =
+  await import("../contacts/contact-store.js");
+let contactInfoById: Record<
+  string,
+  { notes: string | null; interactionCount: number }
+> = {};
+mock.module("../contacts/contact-store.js", () => ({
+  ...realContactStoreForAssemblyTest,
+  findContactInfoById: (contactId: string) =>
+    contactInfoById[contactId] ?? null,
+}));
+
+// `resolveTurnInboundActorContext` must NOT re-resolve ACL via the actor-trust
+// resolver on the fresh-inbound path. Track calls so the tests can assert it
+// is never invoked.
+const realActorTrustResolverForAssemblyTest = await import(
+  "../runtime/actor-trust-resolver.js"
+);
+let resolveActorTrustCalls = 0;
+mock.module("../runtime/actor-trust-resolver.js", () => ({
+  ...realActorTrustResolverForAssemblyTest,
+  resolveActorTrust: (
+    ...args: Parameters<
+      typeof realActorTrustResolverForAssemblyTest.resolveActorTrust
+    >
+  ) => {
+    resolveActorTrustCalls += 1;
+    return realActorTrustResolverForAssemblyTest.resolveActorTrust(...args);
+  },
+}));
+
 // PKB search is mocked so the reminder-hints tests can assert behavior
 // without standing up Qdrant. The mock returns whatever is staged in
 // `pkbSearchResults` / `pkbSearchThrows` for the enclosing test.
@@ -88,6 +122,7 @@ import {
   loadSlackActiveThreadFocusBlock,
   loadSlackChronologicalContext,
   loadSlackChronologicalMessages,
+  NON_INTERACTIVE_CONTEXT_BLOCK,
   resolveChannelCapabilities,
   resolveTurnInboundActorContext,
   resolveTurnModelProfileLabel,
@@ -123,7 +158,7 @@ import { getWorkspacePromptPath } from "../util/platform.js";
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block by
 // reading the live conversation's persisted message rows, so the schema must
 // exist before any Slack-channel assembly test runs.
-initializeDb();
+await initializeDb();
 
 // The pkb-reminder injector derives PKB-active state from the workspace itself
 // — `readPkbContext()` returning content behind the personal-memory trust gate
@@ -941,6 +976,32 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(allText).toContain("<knowledge_base>");
   });
 
+  test("captures background-turn / channel-capabilities / non-interactive-context for metadata persistence", async () => {
+    // These three blocks must be captured into `blocks` so persistInjectionBlocks
+    // writes them to message metadata and loadFromDb rehydrates them on a
+    // reload/fork (background-source memory retrospective cache parity — see the
+    // rehydration-order tests in conversation-lifecycle.test.ts). background-turn
+    // fires only for a background/scheduled live conversation, so register one
+    // under the turn's conversation id.
+    setConversation("injection-mode-conv", {
+      conversationId: "injection-mode-conv",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      surfaceState: new Map(),
+      channelCapabilities,
+      conversationType: "background",
+    } as never);
+
+    const { blocks } = await applyRuntimeInjections(baseMessages, fullOptions);
+
+    expect(blocks.backgroundTurnBlock).toContain("<background_turn>");
+    expect(blocks.channelCapabilitiesBlock).toContain("<channel_capabilities>");
+    expect(blocks.nonInteractiveContextBlock).toBe(
+      NON_INTERACTIVE_CONTEXT_BLOCK,
+    );
+  });
+
   test("explicit mode: 'full' behaves the same as default", async () => {
     const { messages: result } = await applyRuntimeInjections(baseMessages, {
       ...fullOptions,
@@ -1449,6 +1510,11 @@ describe("applyRuntimeInjections with nowScratchpad", () => {
 // ---------------------------------------------------------------------------
 
 describe("resolveTurnInboundActorContext", () => {
+  beforeEach(() => {
+    contactInfoById = {};
+    resolveActorTrustCalls = 0;
+  });
+
   /**
    * No trust context means there is no inbound actor to ground the turn on, so
    * the actor section is suppressed.
@@ -1456,7 +1522,7 @@ describe("resolveTurnInboundActorContext", () => {
   test("returns null when there is no trust context", () => {
     // GIVEN a turn with no trust context
     // WHEN the inbound actor context is resolved
-    const actorContext = resolveTurnInboundActorContext(undefined, "asst-1");
+    const actorContext = resolveTurnInboundActorContext(undefined);
 
     // THEN there is no actor context to inject
     expect(actorContext).toBeNull();
@@ -1467,8 +1533,7 @@ describe("resolveTurnInboundActorContext", () => {
    * only renders actor fields for non-guardian actors.
    */
   test("returns null on guardian turns", () => {
-    // GIVEN a guardian trust context (no requester chat id, so the direct
-    // projection branch is taken)
+    // GIVEN a guardian trust context
     const trustContext: TrustContext = {
       sourceChannel: "vellum",
       trustClass: "guardian",
@@ -1476,40 +1541,78 @@ describe("resolveTurnInboundActorContext", () => {
     };
 
     // WHEN the inbound actor context is resolved
-    const actorContext = resolveTurnInboundActorContext(trustContext, "asst-1");
+    const actorContext = resolveTurnInboundActorContext(trustContext);
 
     // THEN the actor section is suppressed for the owner
     expect(actorContext).toBeNull();
   });
 
   /**
-   * A non-guardian trust context without the identity fields needed for the
-   * unified actor-trust lookup is projected directly into the actor context.
+   * ACL fields (trust class, member status/policy, guardian identity) project
+   * from the verdict-derived trust context — without re-resolving via the
+   * actor-trust resolver.
    */
-  test("projects a non-guardian trust context directly", () => {
-    // GIVEN a trusted-contact trust context lacking requester chat/user ids
+  test("projects ACL from the verdict-derived trust context", () => {
+    // GIVEN a trusted-contact trust context carrying verdict-derived ACL fields
     const trustContext: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "trusted_contact",
       requesterIdentifier: "@bob_handle",
       requesterDisplayName: "Bob",
       requesterSenderDisplayName: "Bobby",
+      requesterExternalUserId: "tg-123",
+      requesterChatId: "chat-1",
+      memberStatus: "active",
+      memberPolicy: "allow",
     };
 
     // WHEN the inbound actor context is resolved
-    const actorContext = resolveTurnInboundActorContext(trustContext, "asst-1");
+    const actorContext = resolveTurnInboundActorContext(trustContext);
 
-    // THEN the trust context is projected into the model-facing actor context
+    // THEN ACL is projected from the context and no ACL re-read happened
     expect(actorContext).toEqual({
       sourceChannel: "telegram",
-      canonicalActorIdentity: null,
+      canonicalActorIdentity: "tg-123",
       actorIdentifier: "@bob_handle",
       actorDisplayName: "Bob",
       actorSenderDisplayName: "Bobby",
       actorMemberDisplayName: undefined,
       trustClass: "trusted_contact",
       guardianIdentity: undefined,
+      memberStatus: "active",
+      memberPolicy: "allow",
     });
+    expect(resolveActorTrustCalls).toBe(0);
+  });
+
+  /**
+   * INFO fields (contact notes, interaction count) are joined locally by the
+   * verdict-stamped contact ID, not re-resolved through the ACL store.
+   */
+  test("populates INFO via the local contactId join", () => {
+    // GIVEN a contact whose INFO is available by id
+    contactInfoById["contact-42"] = {
+      notes: "prefers async updates",
+      interactionCount: 7,
+    };
+    const trustContext: TrustContext = {
+      sourceChannel: "telegram",
+      trustClass: "trusted_contact",
+      requesterExternalUserId: "tg-123",
+      requesterChatId: "chat-1",
+      requesterContactId: "contact-42",
+      memberStatus: "active",
+      memberPolicy: "allow",
+    };
+
+    // WHEN the inbound actor context is resolved
+    const actorContext = resolveTurnInboundActorContext(trustContext);
+
+    // THEN INFO comes from the local join and ACL stays verdict-derived
+    expect(actorContext?.contactNotes).toBe("prefers async updates");
+    expect(actorContext?.contactInteractionCount).toBe(7);
+    expect(actorContext?.memberStatus).toBe("active");
+    expect(resolveActorTrustCalls).toBe(0);
   });
 });
 

package/src/__tests__/conversation-slash-queue.test.ts

@@ -150,6 +150,12 @@ mock.module("../memory/retriever.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     constructor() {}
     updateConfig() {}
     shouldCompact() {

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -151,6 +151,12 @@ mock.module("../memory/retriever.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     constructor() {}
     updateConfig() {}
     shouldCompact() {

package/src/__tests__/conversation-speed-override.test.ts

@@ -167,6 +167,12 @@ mock.module("../memory/retriever.js", () => ({
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
     constructor() {}
     updateConfig() {}
     shouldCompact() {

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

@@ -14,7 +14,7 @@ mock.module("../prompts/user-reference.js", () => ({
   resolveUserReference: () => "Alice",
 }));
 
-import { getSqlite } from "../memory/db-connection.js";
+import { getMemorySqlite, getSqlite } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   CONVERSATION_STARTERS_STALE_TTL_MS,
@@ -23,7 +23,7 @@ import {
 } from "../runtime/routes/conversation-starter-routes.js";
 import { RouteError } from "../runtime/routes/errors.js";
 
-initializeDb();
+await initializeDb();
 
 /**
  * Dispatch a request to the ROUTES array by matching endpoint + method.
@@ -66,7 +66,7 @@ function dispatch(path: string, method = "GET"): unknown | Promise<unknown> {
 function clearTables() {
   getSqlite().run("DELETE FROM conversation_starters");
   getSqlite().run("DELETE FROM memory_graph_nodes");
-  getSqlite().run("DELETE FROM memory_jobs");
+  getMemorySqlite()!.run("DELETE FROM memory_jobs");
   getSqlite().run("DELETE FROM memory_checkpoints");
 }
 
@@ -129,7 +129,7 @@ function setCheckpoint(key: string, value: string, updatedAt = Date.now()) {
 
 function insertStarterJob(scopeId = "default", status = "pending") {
   const now = Date.now();
-  getSqlite().run(
+  getMemorySqlite()!.run(
     `INSERT INTO memory_jobs (
       id, type, payload, status, attempts, deferrals, run_after, last_error,
       started_at, created_at, updated_at
@@ -140,7 +140,7 @@ function insertStarterJob(scopeId = "default", status = "pending") {
 
 function countStarterJobs() {
   return (
-    getSqlite()
+    getMemorySqlite()!
       .prepare(
         `SELECT COUNT(*) AS c FROM memory_jobs WHERE type = 'generate_conversation_starters'`,
       )

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

@@ -27,7 +27,7 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { skillLoadedEvents } from "../memory/schema.js";
 // Initialize db once before all tests
-initializeDb();
+await initializeDb();
 
 describe("deleteLastExchange", () => {
   beforeEach(() => {

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -44,7 +44,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { queryUnreportedOnboardingEvents } from "../memory/onboarding-events-store.js";
 import { activationSessions, onboardingEvents } from "../memory/schema.js";
 
-initializeDb();
+await initializeDb();
 
 interface ProcessMessageCall {
   content: string;
@@ -184,7 +184,7 @@ describe("activation moment emission from ui_show surface commits", () => {
     await surfaceProxyResolver(ctx, "ui_show", {
       surface_type: "card",
       title: "Inbox cleaned",
-      data: { text: "Archived 1,240 emails" },
+      data: { body: "Archived 1,240 emails" },
       activation_moment: "first_wow_executed",
     });
 
@@ -210,7 +210,7 @@ describe("activation moment emission from ui_show surface commits", () => {
     await surfaceProxyResolver(ctx, "ui_show", {
       surface_type: "card",
       title: "Result",
-      data: { text: "x" },
+      data: { body: "x" },
       activation_moment: "first_wow_executed",
     });
     expect(queryUnreportedOnboardingEvents(0, undefined, 10)).toHaveLength(0);
@@ -283,7 +283,7 @@ describe("activation moment emission from ui_show surface commits", () => {
     await surfaceProxyResolver(ctx, "ui_show", {
       surface_type: "card",
       title: "Start something",
-      data: { text: "Kick off a draft" },
+      data: { body: "Kick off a draft" },
       actions: [{ id: "go", label: "Go", style: "primary" }],
       activation_moment: "moment_1",
     });