@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -76,7 +76,6 @@ function makeTarget(): Conversation {
       run: async ({ messages }: { messages: Message[] }) => ({
         history: messages,
         exitReason: null,
-        appendedNewMessages: false,
         newMessages: [],
       }),
     },

package/src/__tests__/approval-cascade.test.ts

@@ -183,6 +183,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

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

@@ -167,7 +167,6 @@ 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: [],
@@ -179,7 +178,6 @@ 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",

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

@@ -114,7 +114,6 @@ mock.module("../daemon/conversation-store.js", () => ({
   mergeConversationOptions: () => {},
   deleteConversationOptions: () => {},
   clearConversationOptions: () => {},
-  setCesClientPromise: () => {},
 }));
 
 // ---------------------------------------------------------------------------

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

@@ -54,7 +54,10 @@ mock.module("../memory/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
-import { buildPersistedAssistantContent } from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  buildPersistedAssistantContent,
+  stampThinkingTiming,
+} from "../daemon/conversation-agent-loop-handlers.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import type { ContentBlock } from "../providers/types.js";
 
@@ -182,3 +185,74 @@ describe("buildPersistedAssistantContent — native activityMetadata", () => {
     expect(block._activityMetadata).toBeUndefined();
   });
 });
+
+describe("stampThinkingTiming", () => {
+  test("stamps internal timing onto thinking blocks by position", () => {
+    // GIVEN a turn that interleaves text and two thinking blocks AND the
+    // per-block timing captured while streaming (one entry per thinking block,
+    // in stream order)
+    const content = [
+      { type: "thinking", thinking: "first", signature: "s1" },
+      { type: "text", text: "answer" },
+      { type: "thinking", thinking: "second", signature: "s2" },
+    ] as unknown as ContentBlock[];
+    const timings = [
+      { startedAt: 100, completedAt: 250 },
+      { startedAt: 400, completedAt: 480 },
+    ];
+
+    // WHEN the content is stamped before persistence
+    const stamped = stampThinkingTiming(content, timings) as unknown as Array<
+      Record<string, unknown>
+    >;
+
+    // THEN each thinking block carries the `_`-prefixed timing for its position
+    expect(stamped[0]).toMatchObject({
+      type: "thinking",
+      _startedAt: 100,
+      _completedAt: 250,
+    });
+    expect(stamped[2]).toMatchObject({
+      type: "thinking",
+      _startedAt: 400,
+      _completedAt: 480,
+    });
+    // AND the interleaved text block is left untouched
+    expect(stamped[1]).toEqual({ type: "text", text: "answer" });
+  });
+
+  test("leaves thinking blocks unstamped when no timing was captured", () => {
+    // GIVEN thinking content but an empty timing list (thinking streaming was
+    // disabled, so no per-block timing was recorded this turn)
+    const content = [
+      { type: "thinking", thinking: "first", signature: "s1" },
+    ] as unknown as ContentBlock[];
+
+    // WHEN the content is stamped with no timing
+    const stamped = stampThinkingTiming(content, []);
+
+    // THEN the original content is returned unchanged so the UI hides duration,
+    // exactly as a tool call with no timing
+    expect(stamped).toBe(content);
+    expect(stamped[0]).not.toHaveProperty("_startedAt");
+  });
+
+  test("stamps only the thinking blocks that have a matching timing entry", () => {
+    // GIVEN two thinking blocks but only one captured timing entry (e.g. the
+    // second block opened after the timing array was already finalized)
+    const content = [
+      { type: "thinking", thinking: "first", signature: "s1" },
+      { type: "thinking", thinking: "second", signature: "s2" },
+    ] as unknown as ContentBlock[];
+    const timings = [{ startedAt: 100, completedAt: 250 }];
+
+    // WHEN the content is stamped
+    const stamped = stampThinkingTiming(content, timings) as unknown as Array<
+      Record<string, unknown>
+    >;
+
+    // THEN the first block is stamped and the unmatched second block is left as-is
+    expect(stamped[0]).toMatchObject({ _startedAt: 100, _completedAt: 250 });
+    expect(stamped[1]).not.toHaveProperty("_startedAt");
+  });
+});

package/src/__tests__/catalog-install-normalize.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Regression tests for catalog entry normalization in catalog-install.ts.
+ *
+ * The platform `/v1/skills/` API flattens skill metadata into top-level
+ * fields (`category`, `display_name`, `icon`) rather than the nested
+ * `metadata.vellum.*` shape used by the local `catalog.json`. Both
+ * `fetchCatalog` (remote) and `readLocalCatalog` (local file) must produce a
+ * canonical `CatalogSkill` whose `metadata.vellum.category` is populated, so
+ * downstream category assignment doesn't fall back to "system" for every skill.
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/env.js", () => ({
+  getPlatformBaseUrl: () => "https://platform.example.com",
+}));
+
+import { fetchCatalog, readLocalCatalog } from "../skills/catalog-install.js";
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+/**
+ * Build a `fetch` stub that responds with `payload` serialized as JSON.
+ *
+ * `Object.assign` attaches the `preconnect` static that Bun's `fetch` type
+ * requires, so the stub satisfies `typeof fetch` without an `as unknown` cast.
+ */
+function stubFetchJson(payload: unknown): typeof fetch {
+  const respond = async () =>
+    new Response(JSON.stringify(payload), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+  return Object.assign(respond, { preconnect: () => {} });
+}
+
+describe("fetchCatalog normalization", () => {
+  test("re-nests the platform's flattened category under metadata.vellum", async () => {
+    globalThis.fetch = stubFetchJson({
+      skills: [
+        {
+          id: "amazon",
+          name: "amazon",
+          display_name: "Amazon",
+          description: "Shop on Amazon",
+          icon: "🛒",
+          category: "commerce",
+          updated_at: "2026-04-19T19:26:17Z",
+        },
+      ],
+    });
+
+    const catalog = await fetchCatalog();
+
+    expect(catalog).toHaveLength(1);
+    const [skill] = catalog;
+    expect(skill.id).toBe("amazon");
+    expect(skill.metadata?.vellum?.category).toBe("commerce");
+    expect(skill.metadata?.vellum?.["display-name"]).toBe("Amazon");
+    expect(skill.icon).toBe("🛒");
+    expect(skill.metadata?.icon).toBe("🛒");
+    expect(skill.updatedAt).toBe("2026-04-19T19:26:17Z");
+  });
+
+  test("leaves category undefined when the API omits it", async () => {
+    globalThis.fetch = stubFetchJson({
+      skills: [{ id: "no-cat", name: "no-cat", description: "d" }],
+    });
+
+    const catalog = await fetchCatalog();
+
+    expect(catalog).toHaveLength(1);
+    expect(catalog[0].metadata?.vellum?.category).toBeUndefined();
+  });
+
+  test("drops malformed entries without throwing", async () => {
+    globalThis.fetch = stubFetchJson({
+      skills: [
+        null,
+        undefined,
+        "not-an-object",
+        { name: "missing-id", description: "d" },
+        { id: 42 },
+        { id: "valid", name: "valid", description: "d", category: "email" },
+      ],
+    });
+
+    const catalog = await fetchCatalog();
+
+    expect(catalog).toHaveLength(1);
+    expect(catalog[0].id).toBe("valid");
+    expect(catalog[0].metadata?.vellum?.category).toBe("email");
+  });
+});
+
+describe("readLocalCatalog normalization", () => {
+  test("reads the nested metadata.vellum.category from catalog.json", () => {
+    const dir = mkdtempSync(join(tmpdir(), "vellum-catalog-"));
+    try {
+      writeFileSync(
+        join(dir, "catalog.json"),
+        JSON.stringify({
+          version: 1,
+          skills: [
+            {
+              id: "tasks",
+              name: "tasks",
+              description: "Task management",
+              metadata: {
+                icon: "✅",
+                vellum: { "display-name": "Tasks", category: "productivity" },
+              },
+            },
+          ],
+        }),
+      );
+
+      const catalog = readLocalCatalog(dir);
+
+      expect(catalog).toHaveLength(1);
+      expect(catalog[0].metadata?.vellum?.category).toBe("productivity");
+      expect(catalog[0].metadata?.vellum?.["display-name"]).toBe("Tasks");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/ces-startup-timeout.test.ts

@@ -4,8 +4,23 @@ import type { CesClient } from "../credential-execution/client.js";
 import {
   awaitCesClientWithTimeout,
   DEFAULT_CES_STARTUP_TIMEOUT_MS,
+  injectCesClientWhenReady,
 } from "../credential-execution/startup-timeout.js";
 
+function makeResolver(initial?: CesClient) {
+  let current = initial;
+  const setCesClient = mock((client: CesClient) => {
+    current = client;
+  });
+  return {
+    getCesClient: () => current,
+    setCesClient,
+  };
+}
+
+/** Wait for the microtask attached to the resolved promise to run. */
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
 describe("awaitCesClientWithTimeout", () => {
   test("clears the fallback timer when the CES client resolves first", async () => {
     const onTimeout = mock(() => {});
@@ -38,3 +53,48 @@ describe("awaitCesClientWithTimeout", () => {
     expect(DEFAULT_CES_STARTUP_TIMEOUT_MS).toBe(20_000);
   });
 });
+
+describe("injectCesClientWhenReady", () => {
+  test("injects the client into an empty resolver once the handshake resolves", async () => {
+    const client = { isReady: () => true } as unknown as CesClient;
+    const resolver = makeResolver();
+
+    injectCesClientWhenReady(Promise.resolve(client), resolver);
+    await flush();
+
+    expect(resolver.setCesClient).toHaveBeenCalledTimes(1);
+    expect(resolver.getCesClient()).toBe(client);
+  });
+
+  test("does not overwrite a client installed by a reconnection", async () => {
+    const reconnected = { isReady: () => true } as unknown as CesClient;
+    const lateStartupClient = { isReady: () => true } as unknown as CesClient;
+    const resolver = makeResolver(reconnected);
+
+    injectCesClientWhenReady(Promise.resolve(lateStartupClient), resolver);
+    await flush();
+
+    expect(resolver.setCesClient).not.toHaveBeenCalled();
+    expect(resolver.getCesClient()).toBe(reconnected);
+  });
+
+  test("is a no-op when the handshake resolves without a client", async () => {
+    const resolver = makeResolver();
+
+    injectCesClientWhenReady(Promise.resolve(undefined), resolver);
+    await flush();
+
+    expect(resolver.setCesClient).not.toHaveBeenCalled();
+    expect(resolver.getCesClient()).toBeUndefined();
+  });
+
+  test("swallows a rejected handshake without injecting", async () => {
+    const resolver = makeResolver();
+
+    injectCesClientWhenReady(Promise.reject(new Error("aborted")), resolver);
+    await flush();
+
+    expect(resolver.setCesClient).not.toHaveBeenCalled();
+    expect(resolver.getCesClient()).toBeUndefined();
+  });
+});

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

@@ -198,6 +198,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact(): Promise<ContextWindowResult> {
       return mockCompactResult;
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/config-managed-gemini-defaults.test.ts

@@ -57,17 +57,8 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeLoggerStub(),
 }));
 
-// ---------------------------------------------------------------------------
-// Feature flag mock — controls whether managed-gemini-embeddings-enabled is on
-// ---------------------------------------------------------------------------
-
-let featureFlagEnabled = false;
-
 mock.module("../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (key: string) => {
-    if (key === "managed-gemini-embeddings-enabled") return featureFlagEnabled;
-    return true;
-  },
+  isAssistantFeatureFlagEnabled: () => true,
   clearFeatureFlagOverridesCache: () => {},
   initFeatureFlagOverrides: async () => {},
   getAssistantFeatureFlagDefaults: () => ({}),
@@ -119,8 +110,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
     invalidateConfigCache();
 
-    // Reset mock state
-    featureFlagEnabled = false;
     originalIsPlatform = process.env.IS_PLATFORM;
     delete process.env.IS_PLATFORM;
   });
@@ -137,10 +126,9 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     }
   });
 
-  test("applies managed Gemini defaults when FF on + IS_PLATFORM + provider auto", () => {
+  test("applies managed Gemini defaults when IS_PLATFORM + provider auto", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -162,22 +150,9 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     expect(qdrantRaw.vectorSize).toBe(3072);
   });
 
-  test("does NOT apply when feature flag is OFF", () => {
-    writeConfig({});
-
-    featureFlagEnabled = false;
-    process.env.IS_PLATFORM = "true";
-
-    const config = loadConfig();
-
-    expect(config.memory.embeddings.provider).toBe("auto");
-    expect(config.memory.qdrant.vectorSize).toBe(384);
-  });
-
   test("does NOT apply when IS_PLATFORM is not set", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     delete process.env.IS_PLATFORM;
 
     const config = loadConfig();
@@ -191,7 +166,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       memory: { embeddings: { provider: "local" } },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -204,7 +178,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       memory: { embeddings: { provider: "openai" } },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -219,7 +192,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -235,7 +207,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       memory: { embeddings: { provider: "ollama" } },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -245,7 +216,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
   test("is idempotent — second loadConfig is a no-op after migration", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -274,7 +244,6 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
       },
     });
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "true";
 
     const config = loadConfig();
@@ -295,22 +264,9 @@ describe("managed Gemini embedding defaults (via loadConfig)", () => {
     expect(qdrantRaw.onDisk).toBe(false);
   });
 
-  test("does NOT apply when both FF off and IS_PLATFORM not set", () => {
-    writeConfig({});
-
-    featureFlagEnabled = false;
-    delete process.env.IS_PLATFORM;
-
-    const config = loadConfig();
-
-    expect(config.memory.embeddings.provider).toBe("auto");
-    expect(config.memory.qdrant.vectorSize).toBe(384);
-  });
-
   test("applies when IS_PLATFORM is '1'", () => {
     writeConfig({});
 
-    featureFlagEnabled = true;
     process.env.IS_PLATFORM = "1";
 
     const config = loadConfig();