@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -39,16 +39,29 @@ import {
 import { getConversationDirPath } from "../memory/conversation-disk-view.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import {
+  loadGraphMemoryState,
+  saveGraphMemoryState,
+} from "../memory/graph/graph-memory-state-store.js";
 import { getRequestLogsByMessageId } from "../memory/llm-request-log-store.js";
 import {
+  bumpRetrospectiveLastRunAt,
+  getRetrospectiveState,
+  upsertRetrospectiveState,
+} from "../memory/memory-retrospective-state.js";
+import {
+  activationState,
   channelInboundEvents,
   conversationAssistantAttentionState,
+  conversationGraphMemoryState,
   conversations,
   externalConversationBindings,
   llmRequestLogs,
   memoryJobs,
+  memoryRetrospectiveState,
   toolInvocations,
 } from "../memory/schema.js";
+import { hydrate as hydrateActivationState } from "../memory/v2/activation-store.js";
 
 initializeDb();
 
@@ -57,6 +70,9 @@ function resetTables(): void {
   db.delete(channelInboundEvents).run();
   db.delete(externalConversationBindings).run();
   db.delete(conversationAssistantAttentionState).run();
+  db.delete(activationState).run();
+  db.delete(conversationGraphMemoryState).run();
+  db.delete(memoryRetrospectiveState).run();
   db.delete(llmRequestLogs).run();
   db.delete(toolInvocations).run();
   db.delete(memoryJobs).run();
@@ -137,7 +153,6 @@ describe("forkConversation", () => {
     ).toBe(true);
   });
 
-
   test("preserves source order when source messages share a timestamp", () => {
     const source = createConversation("Equal timestamp thread");
     const db = getDb();
@@ -500,4 +515,229 @@ describe("forkConversation", () => {
     expect(forkInboundEventCount).toBe(0);
     expect(forkQueuedWorkCount).toBe(0);
   });
+
+  test("copies the parent's v2 activation state into the fork", async () => {
+    const source = createConversation("Activation thread");
+    const sourceMessage = await addMessage(
+      source.id,
+      "user",
+      "Tell me about the Q3 launch plan",
+      undefined,
+      { skipIndexing: true },
+    );
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: sourceMessage.id,
+        stateJson: JSON.stringify({
+          "concepts/q3-launch-plan": 0.71,
+          "concepts/marketing-ops": 0.34,
+        }),
+        everInjectedJson: JSON.stringify([
+          { slug: "concepts/q3-launch-plan", turn: 1 },
+          { slug: "concepts/marketing-ops", turn: 1 },
+        ]),
+        currentTurn: 2,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    const childState = await hydrateActivationState(db, fork.id);
+    expect(childState).toEqual({
+      messageId: sourceMessage.id,
+      state: {
+        "concepts/q3-launch-plan": 0.71,
+        "concepts/marketing-ops": 0.34,
+      },
+      everInjected: [
+        { slug: "concepts/q3-launch-plan", turn: 1 },
+        { slug: "concepts/marketing-ops", turn: 1 },
+      ],
+      currentTurn: 2,
+      updatedAt: 1_700_000_000_000,
+    });
+
+    // Parent state is untouched.
+    const parentState = await hydrateActivationState(db, source.id);
+    expect(parentState?.currentTurn).toBe(2);
+  });
+
+  test("copies the parent's v1 graph memory state into the fork", async () => {
+    const source = createConversation("Graph tracker thread");
+    await addMessage(
+      source.id,
+      "user",
+      "Look up alice's preferences",
+      undefined,
+      {
+        skipIndexing: true,
+      },
+    );
+
+    const trackerSnapshot = JSON.stringify({
+      initialized: true,
+      needsReload: false,
+      inContext: ["node-alice", "node-bob"],
+      log: [
+        { nodeId: "node-alice", turn: 1 },
+        { nodeId: "node-bob", turn: 2 },
+      ],
+      currentTurn: 3,
+    });
+    saveGraphMemoryState(source.id, trackerSnapshot);
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(loadGraphMemoryState(fork.id)).toBe(trackerSnapshot);
+    // Parent row is untouched.
+    expect(loadGraphMemoryState(source.id)).toBe(trackerSnapshot);
+  });
+
+  test("leaves both memory state tables empty when the parent has none", async () => {
+    const source = createConversation("Pristine thread");
+    await addMessage(source.id, "user", "first message", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    const db = getDb();
+    expect(await hydrateActivationState(db, fork.id)).toBeNull();
+    expect(loadGraphMemoryState(fork.id)).toBeNull();
+  });
+});
+
+describe("forkConversation + memory_retrospective_state", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("does not seed state when the source has none", async () => {
+    const source = createConversation("Untouched thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(getRetrospectiveState(fork.id)).toBeNull();
+  });
+
+  test("maps the source pointer when it falls within the copied range", async () => {
+    const source = createConversation("In-range thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const processedMessage = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "user", "Message 3", undefined, {
+      skipIndexing: true,
+    });
+
+    upsertRetrospectiveState({
+      conversationId: source.id,
+      lastProcessedMessageId: processedMessage.id,
+      lastRunAt: 1_700_000_000_000,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkState = getRetrospectiveState(fork.id);
+    const forkMessages = getMessages(fork.id);
+    const mappedProcessedId = forkMessages.find((m) => {
+      const md = parseMetadata(m.metadata) as {
+        forkSourceMessageId?: string;
+      } | null;
+      return md?.forkSourceMessageId === processedMessage.id;
+    })?.id;
+
+    expect(mappedProcessedId).toBeDefined();
+    expect(forkState).not.toBeNull();
+    expect(forkState?.lastProcessedMessageId).toBe(mappedProcessedId);
+    expect(forkState?.lastRunAt).toBe(1_700_000_000_000);
+  });
+
+  test("clamps to the last copied message when the source pointer is past the fork boundary", async () => {
+    const source = createConversation("Past-boundary thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    const branchPoint = await addMessage(
+      source.id,
+      "assistant",
+      "Message 2",
+      undefined,
+      { skipIndexing: true },
+    );
+    const pastBoundaryMessage = await addMessage(
+      source.id,
+      "user",
+      "Message 3",
+      undefined,
+      { skipIndexing: true },
+    );
+    await addMessage(source.id, "assistant", "Message 4", undefined, {
+      skipIndexing: true,
+    });
+
+    upsertRetrospectiveState({
+      conversationId: source.id,
+      lastProcessedMessageId: pastBoundaryMessage.id,
+      lastRunAt: 1_700_000_000_000,
+    });
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: branchPoint.id,
+    });
+    const forkState = getRetrospectiveState(fork.id);
+    const forkMessages = getMessages(fork.id);
+    const lastForkedMessageId = forkMessages.at(-1)?.id;
+
+    expect(forkMessages).toHaveLength(2);
+    expect(forkState?.lastProcessedMessageId).toBe(lastForkedMessageId);
+    expect(forkState?.lastRunAt).toBe(1_700_000_000_000);
+  });
+
+  test("preserves the empty-string sentinel from a failure-only source", async () => {
+    const source = createConversation("Failure-only thread");
+    await addMessage(source.id, "user", "Message 1", undefined, {
+      skipIndexing: true,
+    });
+    bumpRetrospectiveLastRunAt(source.id, 1_700_000_000_000);
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkState = getRetrospectiveState(fork.id);
+
+    expect(forkState?.lastProcessedMessageId).toBe("");
+    expect(forkState?.lastRunAt).toBe(1_700_000_000_000);
+  });
+
+  test("copies lastRunAt so the cooldown gate inherits from the source", async () => {
+    const source = createConversation("Cooldown thread");
+    const message = await addMessage(
+      source.id,
+      "user",
+      "Message 1",
+      undefined,
+      { skipIndexing: true },
+    );
+    upsertRetrospectiveState({
+      conversationId: source.id,
+      lastProcessedMessageId: message.id,
+      lastRunAt: 1_700_000_000_000,
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+
+    expect(getRetrospectiveState(fork.id)?.lastRunAt).toBe(1_700_000_000_000);
+  });
 });

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

@@ -78,7 +78,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       },
     });
 
-    const result = profileRoute.handler({
+    const result = await profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: "quality-optimized" },
       headers: {},
@@ -86,7 +86,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
 
     await Promise.resolve();
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       conversationId: conversation.id,
       profile: "quality-optimized",
     });
@@ -104,23 +104,23 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
     subscription.dispose();
   });
 
-  test("rejects unknown profile names with BadRequestError", () => {
+  test("rejects unknown profile names with BadRequestError", async () => {
     const conversation = createConversation("inference-profile-unknown");
 
-    expect(() =>
+    await expect(
       profileRoute.handler({
         pathParams: { id: conversation.id },
         body: { profile: "does-not-exist" },
         headers: {},
       }),
-    ).toThrow(BadRequestError);
+    ).rejects.toThrow(BadRequestError);
     expect(getConversation(conversation.id)?.inferenceProfile).toBeNull();
   });
 
   test("clears the override when profile is null", async () => {
     const conversation = createConversation("inference-profile-clear");
 
-    profileRoute.handler({
+    await profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: "balanced" },
       headers: {},
@@ -137,7 +137,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       },
     });
 
-    const result = profileRoute.handler({
+    const result = await profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: null },
       headers: {},
@@ -145,7 +145,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
 
     await Promise.resolve();
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       conversationId: conversation.id,
       profile: null,
     });
@@ -158,7 +158,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
   test("skips write and event when the profile is unchanged", async () => {
     const conversation = createConversation("inference-profile-noop");
 
-    profileRoute.handler({
+    await profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: "balanced" },
       headers: {},
@@ -175,7 +175,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
       },
     });
 
-    const result = profileRoute.handler({
+    const result = await profileRoute.handler({
       pathParams: { id: conversation.id },
       body: { profile: "balanced" },
       headers: {},
@@ -183,7 +183,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
 
     await Promise.resolve();
 
-    expect(result).toEqual({
+    expect(result).toMatchObject({
       conversationId: conversation.id,
       profile: "balanced",
     });
@@ -193,13 +193,13 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
     subscription.dispose();
   });
 
-  test("throws NotFoundError when the conversation does not exist", () => {
-    expect(() =>
+  test("throws NotFoundError when the conversation does not exist", async () => {
+    await expect(
       profileRoute.handler({
         pathParams: { id: "missing" },
         body: { profile: "balanced" },
         headers: {},
       }),
-    ).toThrow(NotFoundError);
+    ).rejects.toThrow(NotFoundError);
   });
 });

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -136,6 +136,7 @@ mock.module("../config/loader.js", () => ({
     "fireworks",
     "brave",
     "perplexity",
+    "tavily",
   ],
   getConfig: () => mockConfig,
   getConfigReadOnly: () => mockConfig,
@@ -465,7 +466,7 @@ describe("End-to-end session creation benchmark", () => {
       timings.push(performance.now() - start);
 
       if (i === 0) {
-        expect(session.eventBus.listenerCount()).toBeGreaterThan(0);
+        expect(session.eventBus.anyListenerCount()).toBeGreaterThan(0);
       }
       session.dispose();
     }

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

@@ -368,4 +368,128 @@ describe("loadFromDb metadata injection rehydration", () => {
     expect(messages).toHaveLength(2);
     expect(messages[0].content).toEqual([{ type: "text", text: "First" }]);
   });
+
+  test("historical user row rehydrates memoryV2StaticBlock between memory and system_reminder", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "mem payload",
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+          pkbSystemReminderBlock:
+            "<system_reminder>\npkb payload\n</system_reminder>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail turn" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].content).toEqual([
+      { type: "text", text: "<memory>\nmem payload\n</memory>" },
+      {
+        type: "text",
+        text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+      },
+      {
+        type: "text",
+        text: "<system_reminder>\npkb payload\n</system_reminder>",
+      },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
+  test("tail user row skips memoryV2StaticBlock", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail" }]),
+        metadata: JSON.stringify({
+          memoryV2StaticBlock: "<memory>\n## Essentials\n\nleak\n</memory>",
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[2].role).toBe("user");
+    // Tail row receives fresh injection on the next turn — the persisted
+    // static block must not rehydrate here.
+    expect(messages[2].content).toEqual([{ type: "text", text: "Tail" }]);
+  });
+
+  test("untrusted-actor view does not rehydrate memoryV2StaticBlock", async () => {
+    mockConversation = defaultConv();
+    // Rows with `trusted_contact` / `unknown` provenance survive the
+    // untrusted-actor row filter, so this isolates the rehydrate gate.
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+        metadata: JSON.stringify({
+          provenanceTrustClass: "trusted_contact",
+          memoryV2StaticBlock:
+            "<memory>\n## Essentials\n\nprivate memory\n</memory>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+        metadata: JSON.stringify({ provenanceTrustClass: "unknown" }),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail" }]),
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    conversation.setTrustContext({
+      trustClass: "trusted_contact",
+      sourceChannel: "telegram",
+    });
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    // The historical row survives row-level filtering but the rehydrate gate
+    // suppresses the personal-memory block.
+    expect(messages[0].content).toEqual([{ type: "text", text: "First" }]);
+  });
 });

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -15,7 +15,7 @@
  * instantiation block use at first-message time.
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Module mocks for downstream side effects (DB writes, slash resolution,
@@ -28,6 +28,20 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
+/**
+ * Per-test capability client roster. Set in individual tests to simulate
+ * a connected macOS client for cross-client drain-path coverage. Reset in
+ * afterEach so tests don't bleed state.
+ */
+let mockCapabilityClients: Array<{ clientId: string; actorPrincipalId?: string }> = [];
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    listClientsByCapability: () => mockCapabilityClients,
+  },
+  broadcastMessage: () => {},
+}));
+
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
@@ -145,6 +159,7 @@ function makeFakeContext(opts: {
     },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
+    ensureHostProxiesForTurn() {},
   } as unknown as ProcessConversationContext & FakeRecord;
   return ctx;
 }
@@ -170,6 +185,10 @@ function makeQueuedMessage(opts: {
 // ---------------------------------------------------------------------------
 
 describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
+  afterEach(() => {
+    mockCapabilityClients = [];
+  });
+
   test("drainSingleMessage re-adds 'app-control' for macOS-sourced queued message", async () => {
     const queue = new MessageQueue();
     const ifCtx: TurnInterfaceContext = {
@@ -280,4 +299,84 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
     expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
     expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
   });
+
+  // ── Cross-client drain-path: web source + macOS client connected ──────
+
+  test("drainSingleMessage re-adds 'app-control' for web-sourced message when macOS client is connected", async () => {
+    mockCapabilityClients = [
+      { clientId: "macos-client-1", actorPrincipalId: "user-1" },
+    ];
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-web-1", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    // web natively supports neither host_cu nor host_app_control, but the
+    // connected macOS client provides both via cross-client routing — so
+    // both skills must be re-preactivated.
+    expect(ctx.preactivatedSkillIdCalls).toContain("app-control");
+    expect(ctx.preactivatedSkillIds).toContain("app-control");
+    expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
+  });
+
+  test("drainSingleMessage does NOT re-add 'app-control' for web-sourced message when no capable client is connected", async () => {
+    // mockCapabilityClients remains [] (reset by afterEach from prior test)
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-web-2", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("app-control");
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+  });
+
+  test("drainSingleMessage re-adds 'computer-use' for web-sourced message when macOS client is connected", async () => {
+    mockCapabilityClients = [
+      { clientId: "macos-client-1", actorPrincipalId: "user-1" },
+    ];
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-web-3", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).toContain("computer-use");
+    expect(ctx.preactivatedSkillIds).toContain("computer-use");
+  });
+
+  test("drainSingleMessage does NOT re-add 'computer-use' for web-sourced message when no capable client is connected", async () => {
+    const queue = new MessageQueue();
+    const ifCtx: TurnInterfaceContext = {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    };
+    queue.push(
+      makeQueuedMessage({ requestId: "req-web-4", turnInterfaceContext: ifCtx }),
+    );
+    const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
+
+    await drainQueue(ctx);
+
+    expect(ctx.preactivatedSkillIdCalls).not.toContain("computer-use");
+  });
 });