@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -167,6 +167,7 @@ const mockFailStalledJobs = mock(() => 0);
 const mockClaimMemoryJobs = mock(() => []);
 mock.module("../memory/jobs-store.js", () => ({
   claimMemoryJobs: mockClaimMemoryJobs,
+  cancelPendingAutomaticConsolidationJobs: mock(() => 0),
   completeMemoryJob: mock(() => {}),
   deferMemoryJob: mock(() => "deferred"),
   EMBED_JOB_TYPES: [],
@@ -178,7 +179,12 @@ mock.module("../memory/jobs-store.js", () => ({
   failStalledJobs: mockFailStalledJobs,
   getMemoryJobCounts: mock(() => ({})),
   hasActiveJobOfType: mock(() => false),
+  isAutomaticConsolidationJob: mock(() => true),
   isMemoryEnabled: () => true,
+  MEMORY_V2_CONSOLIDATION_JOB_TRIGGERS: {
+    automatic: "automatic",
+    manual: "manual",
+  },
   resetRunningJobsToPending: mock(() => 0),
   SLOW_LLM_JOB_TYPES: [],
   upsertAutoAnalysisJob: mock(() => "job-auto-analysis"),

package/src/__tests__/btw-routes.test.ts

@@ -6,7 +6,9 @@
  * and no session.processing mutation.
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 // ---------------------------------------------------------------------------
 // Mocks — must be defined before importing the module under test
@@ -76,7 +78,13 @@ mock.module("../runtime/routes/identity-intro-cache.js", () => ({
   getCachedIntro: () => null,
   readWorkspaceIdentityIntro: () => null,
   setCachedIntro: () => {},
-  computeIdentityContentHash: () => "test-hash",
+}));
+
+const assistantFeatureFlags: Record<string, boolean> = {};
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) =>
+    assistantFeatureFlags[key] ?? false,
 }));
 
 // Mock getOrCreateConversation from conversation-store so the handler
@@ -123,6 +131,7 @@ import {
   ServiceUnavailableError,
 } from "../runtime/routes/errors.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -177,6 +186,12 @@ function makeMockSession(
 const route = ROUTES.find((r) => r.endpoint === "btw" && r.method === "POST");
 if (!route) throw new Error("btw route not found in ROUTES");
 
+beforeEach(() => {
+  for (const key of Object.keys(assistantFeatureFlags)) {
+    delete assistantFeatureFlags[key];
+  }
+});
+
 async function callHandler(
   body: Record<string, unknown>,
 ): Promise<{ result: unknown; error?: unknown }> {
@@ -324,7 +339,25 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.modelIntent).toBeUndefined();
   });
 
-  test("greeting requests pass callSite: 'emptyStateGreeting'", async () => {
+  test("greeting requests return static fallback when the dynamic greetings flag is off", async () => {
+    mockGetOrCreateConversation.mockClear();
+
+    const { result } = await callHandler({
+      conversationKey: "greeting",
+      content: "Generate a greeting",
+    });
+    const text = await readStream(result as ReadableStream<Uint8Array>);
+
+    expect(text).toContain(
+      `event: btw_text_delta\ndata: {"text":"What are we working on?"}`,
+    );
+    expect(text).toContain("event: btw_complete\ndata: {}");
+    expect(mockGetOrCreateConversation).not.toHaveBeenCalled();
+  });
+
+  test("greeting requests pass callSite: 'emptyStateGreeting' when the dynamic greetings flag is on", async () => {
+    assistantFeatureFlags["empty-state-dynamic-greetings"] = true;
+
     const provider = makeMockProvider();
     const session = makeMockSession(provider);
     mockGetOrCreateConversation.mockImplementationOnce(async () => session);
@@ -356,6 +389,32 @@ describe("POST /v1/btw", () => {
     expect(options!.config!.callSite).toBe("identityIntro");
   });
 
+  test("identity intro requests do not synthesize a static name greeting", async () => {
+    const identityPath = join(getWorkspaceDir(), "IDENTITY.md");
+    writeFileSync(
+      identityPath,
+      "# Identity\n\n- **Name:** Example Assistant\n",
+      "utf-8",
+    );
+
+    try {
+      const provider = makeMockProvider();
+      const session = makeMockSession(provider);
+      mockGetOrCreateConversation.mockImplementationOnce(async () => session);
+
+      const { result } = await callHandler({
+        conversationKey: "identity-intro",
+        content: "Generate an intro",
+      });
+      const text = await readStream(result as ReadableStream<Uint8Array>);
+
+      expect(provider.sendMessage).toHaveBeenCalledTimes(1);
+      expect(text).not.toContain("Hi, I'm Example Assistant!");
+    } finally {
+      rmSync(identityPath, { force: true });
+    }
+  });
+
   // -- No persistence --
 
   test("does not persist any messages (addMessage never called)", async () => {

package/src/__tests__/build-persisted-content.test.ts

@@ -0,0 +1,184 @@
+/**
+ * Tests for `buildPersistedAssistantContent` stamping native web-search
+ * activity (`_activityMetadata`) onto `server_tool_use` blocks at persist time.
+ *
+ * Native Anthropic web_search resolves mid-stream — `server_tool_complete`
+ * fires before `message_complete` — so the captured activity is available when
+ * the content is persisted. Unlike external provider tools, a pure-native turn
+ * has no `tool_result` and never runs `annotatePersistedAssistantMessage`, so
+ * stamping must happen here or the WebSearchProgressCard is lost on a history
+ * reopen. Read-side coverage lives in server-history-render.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: () => null,
+  updateMessageContent: () => {},
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import { buildPersistedAssistantContent } from "../daemon/conversation-agent-loop-handlers.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import type { ContentBlock } from "../providers/types.js";
+
+const webSearchActivity: ToolActivityMetadata = {
+  webSearch: {
+    query: "vellum docs",
+    provider: "anthropic-native",
+    resultCount: 1,
+    durationMs: 88,
+    results: [
+      {
+        rank: 1,
+        title: "Vellum",
+        url: "https://vellum.ai",
+        domain: "vellum.ai",
+      },
+    ],
+  },
+};
+
+function findBlockById(
+  blocks: ContentBlock[],
+  id: string,
+): Record<string, unknown> {
+  const block = (blocks as unknown as Array<Record<string, unknown>>).find(
+    (b) => b.id === id,
+  );
+  if (!block) throw new Error(`block ${id} not found`);
+  return block;
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("buildPersistedAssistantContent — native activityMetadata", () => {
+  let activity: Map<string, ToolActivityMetadata>;
+
+  beforeEach(() => {
+    activity = new Map();
+  });
+
+  test("stamps captured activity onto a pure-native server_tool_use block", () => {
+    // GIVEN a turn whose only tool is a native server_tool_use whose activity
+    // was captured at server_tool_complete (no external tool_result, so the
+    // annotate pass never runs for this turn)
+    const nativeId = "srvtu_native_search";
+    activity.set(nativeId, webSearchActivity);
+    const rawBlocks = [
+      { type: "text", text: "Let me search." },
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN the server_tool_use block carries the native activity verbatim so it
+    // survives a history reopen
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toEqual(webSearchActivity);
+  });
+
+  test("leaves a server_tool_use block untouched when no activity was captured", () => {
+    // GIVEN a native server_tool_use with no entry in the activity map
+    const nativeId = "srvtu_no_activity";
+    const rawBlocks = [
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN no _activityMetadata is written
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+
+  test("does not stamp external tool_use blocks (handled by the annotate pass)", () => {
+    // GIVEN an external tool_use block whose id happens to have captured
+    // activity (external activity is stamped later in handleToolResult, not here)
+    const externalId = "tu_external_search";
+    activity.set(externalId, webSearchActivity);
+    const rawBlocks = [
+      {
+        type: "tool_use",
+        id: externalId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence
+    const built = buildPersistedAssistantContent(rawBlocks, [], activity);
+
+    // THEN the tool_use block is left untouched by this function
+    const block = findBlockById(built, externalId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+
+  test("does not stamp when no activity map is provided", () => {
+    // GIVEN a native server_tool_use block AND no activity map argument
+    const nativeId = "srvtu_no_map";
+    const rawBlocks = [
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is built for persistence without the optional map
+    const built = buildPersistedAssistantContent(rawBlocks, []);
+
+    // THEN no _activityMetadata is written
+    const block = findBlockById(built, nativeId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+});

package/src/__tests__/catalog-files.test.ts

@@ -963,7 +963,7 @@ describe("createVellumCatalogProvider", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.origin).toBe("vellum");
     expect(slim!.status).toBe("available");
-    expect(slim!.category).toBe("knowledge");
+    expect(slim!.category).toBe("system");
   });
 
   test("toSlimSkill returns null for unknown skill", async () => {

package/src/__tests__/clawhub-files.test.ts

@@ -291,7 +291,7 @@ describe("toSlimSkill", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.status).toBe("available");
     expect(slim!.origin).toBe("clawhub");
-    expect(slim!.category).toBe("knowledge");
+    expect(slim!.category).toBe("integrations");
 
     // Clawhub-specific fields
     const clawhub = slim as unknown as Record<string, unknown>;

package/src/__tests__/compaction-pipeline.test.ts

@@ -113,7 +113,7 @@ describe("compaction pipeline", () => {
     const args: CompactionArgs = {
       messages: [{ role: "user", content: "hi" }],
       signal: new AbortController().signal,
-      options: { lastCompactedAt: 42, precomputedEstimate: 1234 },
+      options: { precomputedEstimate: 1234 },
     };
 
     // No middleware registered — the runner invokes the terminal directly.

package/src/__tests__/compaction.benchmark.test.ts

@@ -172,34 +172,4 @@ describe("Compaction benchmark", () => {
     expect(result.summaryCalls).toBe(1);
     expect(result.summaryCalls).toBe(counter.calls);
   });
-
-  test("severe pressure triggers compaction even during cooldown", async () => {
-    const counter = { calls: 0 };
-    const provider = makeSummaryProvider(counter);
-    // Use a tighter maxInputTokens so 90 turns exceeds the 95% severe threshold
-    const config = {
-      ...makeConfig(),
-      maxInputTokens: 4000,
-      targetBudgetRatio: 0.55,
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-
-    const messages = makeLongMessages(90);
-    const estimated = estimatePromptTokens(messages, "system prompt", {
-      providerName: "mock",
-    });
-    expect(estimated).toBeGreaterThan(config.maxInputTokens * 0.95);
-
-    // Simulate being within cooldown by setting lastCompactedAt to now
-    const result = await manager.maybeCompact(messages, undefined, {
-      lastCompactedAt: Date.now(),
-    });
-
-    expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBeGreaterThan(0);
-  });
 });

package/src/__tests__/config-watcher.test.ts

@@ -231,7 +231,7 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
-  test("SOUL.md change triggers identity intro invalidation", async () => {
+  test("SOUL.md change triggers identity intro refetch notification", async () => {
     let introCallCount = 0;
     watcher.start(
       onConversationEvict,

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

@@ -108,8 +108,13 @@ mock.module("../workspace/git-service.js", () => ({
   }),
 }));
 
-// Track all messages persisted to DB
+// Track all messages persisted to DB via addMessage (single-shot writes).
 let persistedMessages: Array<{ role: string; content: string }> = [];
+// Track the latest content written into each reserved row (reserve + update
+// pattern). Tool results persist on arrival and finalize at the loop boundary
+// through this path, so the final value per row id is what lands in the DB.
+let reservedRowContent: Map<string, string> = new Map();
+let reserveCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
@@ -139,8 +144,10 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
-  updateMessageContent: mock(() => {}),
+  reserveMessage: mock(async () => ({ id: `msg-reserve-${++reserveCounter}` })),
+  updateMessageContent: mock((id: string, content: string) => {
+    reservedRowContent.set(id, content);
+  }),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -226,8 +233,11 @@ mock.module("../agent/loop.js", () => ({
         isError: false,
       });
 
-      // Abort happens before second tool
-      // Synthesize cancelled result for tu_2 (what the real AgentLoop does)
+      // Abort happens before second tool. The real AgentLoop synthesizes
+      // cancelled results into history AND emits a `cancelled` tool_result
+      // event per tool so the orchestrator captures them for persistence and
+      // forwards them to the client. tu_1 (already captured via its real
+      // tool_result event) wins via the handler's gap-fill guard.
       const resultBlocks: ContentBlock[] = [
         {
           type: "tool_result",
@@ -243,8 +253,27 @@ mock.module("../agent/loop.js", () => ({
         },
       ];
       history.push({ role: "user", content: resultBlocks });
+      onEvent({
+        type: "tool_result",
+        toolUseId: "tu_1",
+        content: "Cancelled by user",
+        isError: true,
+        cancelled: true,
+      });
+      onEvent({
+        type: "tool_result",
+        toolUseId: "tu_2",
+        content: "Cancelled by user",
+        isError: true,
+        cancelled: true,
+      });
 
-      return { history, exitReason: null };
+      return {
+        history,
+        exitReason: null,
+        appendedNewMessages: true,
+        newMessages: history.slice(messages.length),
+      };
     }
   },
 }));
@@ -295,6 +324,8 @@ function makeConversation(): Conversation {
 describe("abort tool result persistence", () => {
   test("abort after first of multiple tool calls still persists all required tool_result blocks", async () => {
     persistedMessages = [];
+    reservedRowContent = new Map();
+    reserveCounter = 0;
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -303,19 +334,26 @@ describe("abort tool result persistence", () => {
       attachments: [],
     });
 
-    // Find user messages in persisted data that contain tool_result
-    const toolResultUserMessages = persistedMessages.filter((m) => {
-      if (m.role !== "user") return false;
-      try {
-        const content = JSON.parse(m.content);
-        return (
-          Array.isArray(content) &&
-          content.some((b: Record<string, unknown>) => b.type === "tool_result")
-        );
-      } catch {
-        return false;
-      }
-    });
+    // Find persisted rows whose final content contains tool_result blocks.
+    // Tool results persist on arrival into one grouped row and finalize at the
+    // abort/loop boundary; the latest content per reserved row id is what lands
+    // in the DB, so one entry per row models the persisted state (a second
+    // entry would mean the batch was wrongly split across rows).
+    const toolResultUserMessages = Array.from(reservedRowContent.values())
+      .map((content) => ({ content }))
+      .filter((m) => {
+        try {
+          const content = JSON.parse(m.content);
+          return (
+            Array.isArray(content) &&
+            content.some(
+              (b: Record<string, unknown>) => b.type === "tool_result",
+            )
+          );
+        } catch {
+          return false;
+        }
+      });
 
     // There should be at least one persisted user message with tool_results
     expect(toolResultUserMessages.length).toBeGreaterThanOrEqual(1);

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

@@ -109,10 +109,14 @@ import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 function makeCtx(
   overrides: Partial<Context> = {},
 ): AgentLoopConversationContext {
+  let processing = true;
   return {
     conversationId: "conv-123",
     messages: [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-    processing: true,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     abortController: new AbortController(),
     currentRequestId: "req-123",
     agentLoop: {
@@ -217,7 +221,7 @@ describe("runAgentLoopImpl disk pressure gate", () => {
       "error_terminal",
       { anchor: "global", requestId: "req-123" },
     ]);
-    expect(ctx.processing).toBe(false);
+    expect(ctx.isProcessing()).toBe(false);
     expect(ctx.abortController).toBeNull();
     expect(ctx.currentRequestId).toBeUndefined();
     expect(drainQueue).toHaveBeenCalledWith("loop_complete");

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

@@ -96,6 +96,9 @@ mock.module("../config/loader.js", () => ({
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: () => 1000,
   estimatePromptTokensRaw: () => 1000,
+  // The preflight overflow gate calls this calibrated wrapper directly; stub
+  // it alongside the others so it returns the same small value.
+  estimatePromptTokensWithTools: () => 1000,
   estimateToolsTokens: () => 0,
 }));
 
@@ -220,10 +223,6 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
     blocks: {},
   }),
   stripInjectionsForCompaction: (msgs: Message[]) => msgs,
-  findLastInjectedNowContent: () => null,
-  readNowScratchpad: () => null,
-  readPkbContext: () => null,
-  getPkbAutoInjectList: () => [],
   isSlackChannelConversation: () => false,
   getSlackCompactionWatermarkForPrefix: () => null,
   loadSlackChronologicalContext: () => null,
@@ -392,6 +391,12 @@ function makeCtx(
       { role: "user", content: [{ type: "text", text: "Hello" }] },
     ] as Message[],
     processing: true,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController: new AbortController(),
     currentRequestId: "test-req",
 
@@ -494,6 +499,7 @@ function makeCtx(
         injectedTokens: 0,
       }),
       retrackCachedNodes: () => {},
+      recordPkbQueryVectors: () => {},
     } as unknown as AgentLoopConversationContext["graphMemory"],
 
     ...overrides,