@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/__tests__/memory-v2-static-injector.test.ts

@@ -11,6 +11,9 @@
  *   - Skips (re)injection when the `<info>` block is already present in the
  *     turn's working messages (presence detection — the block persists in
  *     history between compactions).
+ *   - Still injects when only a dynamic `<memory>` activation block is present
+ *     (that wrapper must not be mistaken for the static block) — both on a
+ *     normal turn and after compaction strips the prior `<info>` block.
  *
  * The injector sources its content itself via `readMemoryV2StaticContent()`
  * behind the personal-memory trust gate, so each test seeds the workspace
@@ -35,7 +38,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 const { defaultInjectors } =
-  await import("../plugins/defaults/injectors/register.js");
+  await import("../plugins/defaults/memory-retrieval/injectors.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
@@ -54,7 +57,6 @@ function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
     conversationId: "conv-test",
     turnIndex: 0,
     trust: { sourceChannel: "vellum", trustClass: "guardian" },
-    injectionInputs: {},
     ...overrides,
   };
 }
@@ -96,7 +98,7 @@ describe("memory-v2-static injector", () => {
 
   test("returns null in minimal mode even with content", async () => {
     seedEssentials("Alice prefers VS Code.");
-    const ctx = makeContext({ injectionInputs: { mode: "minimal" } });
+    const ctx = makeContext({ mode: "minimal" });
     expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
   });
 
@@ -140,10 +142,12 @@ describe("memory-v2-static injector", () => {
     expect(await memoryV2StaticInjector.produce(ctx, runMessages)).toBeNull();
   });
 
-  test("skips (re)injection when a legacy <memory>-wrapped static block is present", async () => {
-    // Rows persisted before the `<info>` switch rehydrate the static block as
-    // `<memory>…</memory>`. Re-injecting a fresh `<info>` copy alongside it
-    // would duplicate the content until the next compaction.
+  test("injects the <info> block even when a dynamic <memory> activation block is present", async () => {
+    // Regression (#33612): the v2 *dynamic* activation block uses the
+    // `<memory>…</memory>` wrapper and `prepareMemory` prepends it to the tail
+    // user message every turn, before this injector runs. The static injector
+    // must NOT treat that as its own `<info>` block — doing so suppressed the
+    // static block on essentially every turn.
     seedEssentials("Alice prefers VS Code.");
     const ctx = makeContext();
     const runMessages: Message[] = [
@@ -152,12 +156,86 @@ describe("memory-v2-static injector", () => {
         content: [
           {
             type: "text",
-            text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            text: "<memory>\n# memory/concepts/foo.md\nactivated page summary\n</memory>",
           },
           { type: "text", text: "What next?" },
         ],
       },
     ];
+    const block = await memoryV2StaticInjector.produce(ctx, runMessages);
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("memory-v2-static");
+    expect(block!.text).toBe(
+      "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
+    );
+  });
+
+  test("reinjects the <info> block after compaction strips it, alongside a fresh <memory> block", async () => {
+    // Post-compaction state: `stripInjectionsForCompaction` removed the prior
+    // `<info>` block, and the next turn's `prepareMemory` re-added a fresh
+    // dynamic `<memory>` block ahead of the chain. With no `<info>` present, the
+    // injector must reinject it rather than skip on the `<memory>` block.
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const postCompactMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<memory>\nactivated page summary\n</memory>" },
+          { type: "text", text: "Continue please." },
+        ],
+      },
+    ];
+    const block = await memoryV2StaticInjector.produce(
+      ctx,
+      postCompactMessages,
+    );
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("memory-v2-static");
+    expect(block!.text).toContain("## Essentials");
+  });
+
+  test("skips (re)injection when the <info> block is carried in a flattened history block", async () => {
+    // Regression: when a historical user message's separate injection content
+    // blocks get collapsed into one text block (observed after a daemon restart
+    // / plugin hot-reload rebuilt the rendered history mid-conversation — the
+    // blocks are joined with "\n"), the `<info>` wrapper is no longer its own
+    // block but a newline-delimited section inside a larger block. Presence
+    // detection must still recognize it; otherwise the injector re-injects a
+    // duplicate `<info>` onto the new tail (the double-injection bug).
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const flattenedFirstUser = [
+      "<workspace>\nRoot: /ws\nFiles: a.md\n</workspace>",
+      "<turn_context>\ncurrent_time: now\n</turn_context>",
+      "<memory>\nactivated page summary\n</memory>",
+      "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
+      "what should we do next?",
+    ].join("\n");
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: flattenedFirstUser }] },
+      { role: "assistant", content: [{ type: "text", text: "On it." }] },
+      { role: "user", content: [{ type: "text", text: "great, continue" }] },
+    ];
     expect(await memoryV2StaticInjector.produce(ctx, runMessages)).toBeNull();
   });
+
+  test("still injects when a user message opens an <info> tag without closing it", async () => {
+    // False-positive guard: the wrapper matcher requires BOTH the opening and
+    // closing tags, so user prose that merely opens an injection-like tag must
+    // not be mistaken for a carried block and suppress injection.
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const runMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\n is this how the tag works?" },
+        ],
+      },
+    ];
+    const block = await memoryV2StaticInjector.produce(ctx, runMessages);
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("memory-v2-static");
+  });
 });

package/src/__tests__/notification-decision-strategy.test.ts

@@ -9,17 +9,17 @@
 
 import { describe, expect, test } from "bun:test";
 
-import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
 import {
   buildAccessRequestContractText,
   buildAccessRequestIdentityLine,
-  composeFallbackCopy,
   hasAccessRequestInstructions,
   hasInviteFlowDirective,
   normalizeForDirectiveMatching,
   sanitizeIdentityField,
   sanitizeMessagePreview,
-} from "../notifications/copy-composer.js";
+} from "../notifications/access-request-copy.js";
+import type { ConversationCandidateSet } from "../notifications/conversation-candidates.js";
+import { composeFallbackCopy } from "../notifications/copy-composer.js";
 import {
   enforceGuardianCallConversationAffinity,
   validateConversationActions,

package/src/__tests__/parallel-tool.benchmark.test.ts

@@ -128,12 +128,19 @@ describe("Parallel tool execution benchmarks", () => {
       return { content: "ok", isError: false };
     };
 
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
     const start = Date.now();
-    await loop.run([userMessage], () => {});
+    await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const elapsed = Date.now() - start;
 
     // Parallel: ~50ms + overhead. Sequential would be ~250ms.
@@ -169,12 +176,19 @@ describe("Parallel tool execution benchmarks", () => {
       return { content: "ok", isError: false };
     };
 
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
     const start = Date.now();
-    await loop.run([userMessage], () => {});
+    await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const elapsed = Date.now() - start;
 
     // All 10 tools should have executed
@@ -222,13 +236,20 @@ describe("Parallel tool execution benchmarks", () => {
       return { content: "ok", isError: false };
     };
 
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
     const events: AgentEvent[] = [];
     const start = Date.now();
-    await loop.run([userMessage], collectEvents(events));
+    await loop.run({
+      messages: [userMessage],
+      onEvent: collectEvents(events),
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const elapsed = Date.now() - start;
 
     // Parallel: ~2000ms (dominated by slow tool). Sequential: ~2400ms (2000 + 4*100).
@@ -289,12 +310,18 @@ describe("Parallel tool execution benchmarks", () => {
         return { content: "should not return", isError: false };
       };
 
-      const loop = new AgentLoop(provider, "system", {
+      const loop = new AgentLoop({
+        provider: provider,
+        systemPrompt: "system",
+        conversationId: "test-conversation",
         tools: dummyTools,
         toolExecutor: toolExecutor,
       });
       const start = Date.now();
-      const { history } = await loop.run([userMessage], () => {}, {
+      const { history } = await loop.run({
+        messages: [userMessage],
+        onEvent: () => {},
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
         signal: controller.signal,
       });
       const elapsed = Date.now() - start;

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Regression test for the durable-downscale path of the image-too-large
+ * recovery (JARVIS-1041 review follow-up).
+ *
+ * When an oversized stored image *can* be shrunk on this host (the common macOS
+ * path where `sips` is available), `persistUnsendableImageDowngrades` must write
+ * the downscaled bytes back to the DB — not leave the original in place. The
+ * latest tool-result media is intentionally kept in context, so leaving the
+ * full-size block would rehydrate and re-reject on every later turn instead of
+ * durably self-healing the conversation.
+ *
+ * `optimizeImageForTransport` needs `sips` and a decodable image to actually
+ * downscale, which is not portable to CI, so it is mocked here to simulate a
+ * successful shrink. The mock is process-global, so this case lives in its own
+ * file (the test runner isolates each file in its own process) to avoid
+ * disturbing the no-op-resize cases in persist-unsendable-image.test.ts.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Module mock (must precede the import of the module under test) ────
+// Simulate a host where resizing succeeds: any oversized image is shrunk to a
+// small, distinct JPEG payload. durableImageReplacement checks the provider
+// caps before calling this, so in-limit images never reach the mock.
+const SHRUNK_DATA = "c2hydW5r"; // base64 for "shrunk"
+mock.module("../agent/image-optimize.js", () => ({
+  optimizeImageForTransport: () => ({
+    data: SHRUNK_DATA,
+    mediaType: "image/jpeg",
+  }),
+}));
+
+import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
+import {
+  addMessage,
+  createConversation,
+  getMessages,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import type { ContentBlock } from "../providers/types.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM memory_segments");
+  db.run("DELETE FROM memory_embeddings");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/** Minimal PNG whose IHDR declares dimensions past the 8000px provider cap. */
+function oversizedPngBase64(): string {
+  const width = 12000;
+  const height = 9000;
+  return Buffer.from(
+    Uint8Array.from([
+      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, // PNG signature
+      0x00, 0x00, 0x00, 0x0d, // IHDR length (13)
+      0x49, 0x48, 0x44, 0x52, // "IHDR"
+      (width >>> 24) & 0xff,
+      (width >>> 16) & 0xff,
+      (width >>> 8) & 0xff,
+      width & 0xff,
+      (height >>> 24) & 0xff,
+      (height >>> 16) & 0xff,
+      (height >>> 8) & 0xff,
+      height & 0xff,
+      0x08, 0x06, 0x00, 0x00, 0x00,
+    ]),
+  ).toString("base64");
+}
+
+function toolResultWithImage(data: string): ContentBlock {
+  return {
+    type: "tool_result",
+    tool_use_id: "toolu_123",
+    content: "Screenshot captured",
+    contentBlocks: [
+      { type: "image", source: { type: "base64", media_type: "image/png", data } },
+    ],
+  };
+}
+
+function storedContent(conversationId: string): ContentBlock[][] {
+  return getMessages(conversationId).map(
+    (row) => JSON.parse(row.content) as ContentBlock[],
+  );
+}
+
+describe("persistUnsendableImageDowngrades (downscalable host)", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  /** JARVIS-1041: an oversized screenshot that CAN be shrunk must persist the
+   *  downscaled bytes, not the note and not the original. */
+  test("persists the downscaled image for a shrinkable tool_result screenshot", async () => {
+    // GIVEN a tool_result holding an oversized but shrinkable screenshot
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(oversizedPngBase64())]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the nested block stays an image, rewritten to the downscaled payload
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    const toolResult = content.find((b) => b.type === "tool_result") as {
+      contentBlocks?: ContentBlock[];
+    };
+    const nested = toolResult.contentBlocks?.[0];
+    expect(nested?.type).toBe("image");
+    expect((nested as Extract<ContentBlock, { type: "image" }>).source.data).toBe(
+      SHRUNK_DATA,
+    );
+  });
+
+  /** Re-running is a no-op: the downscaled payload is within limits. */
+  test("is idempotent after a downscale rewrite", async () => {
+    // GIVEN a conversation whose oversized screenshot was already downscaled
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(oversizedPngBase64())]),
+      { skipIndexing: true },
+    );
+    expect(persistUnsendableImageDowngrades(conv.id)).toBe(1);
+
+    // WHEN the downgrade runs again
+    const secondRun = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing further is rewritten
+    expect(secondRun).toBe(0);
+  });
+});

package/src/__tests__/persist-unsendable-image.test.ts

@@ -14,7 +14,10 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
+import {
+  oversizedImageReplacement,
+  persistUnsendableImageDowngrades,
+} from "../daemon/persist-unsendable-image.js";
 import {
   addMessage,
   createConversation,
@@ -87,6 +90,20 @@ function imageBlock(data: string): ContentBlock {
   };
 }
 
+/**
+ * A tool_result carrying a nested image in its contentBlocks, mirroring what a
+ * browser screenshot produces. This is the JARVIS-1041 shape: the oversized
+ * image lives at tool_result.contentBlocks, never as a top-level block.
+ */
+function toolResultWithImage(data: string): ContentBlock {
+  return {
+    type: "tool_result",
+    tool_use_id: "toolu_123",
+    content: "Screenshot captured",
+    contentBlocks: [imageBlock(data)],
+  };
+}
+
 function storedContent(conversationId: string): ContentBlock[][] {
   return getMessages(conversationId).map(
     (row) => JSON.parse(row.content) as ContentBlock[],
@@ -194,6 +211,61 @@ describe("persistUnsendableImageDowngrades", () => {
     expect(content.some((b) => b.type === "image")).toBe(false);
   });
 
+  /** JARVIS-1041: the oversized image is nested inside a tool_result (e.g. a
+   *  browser screenshot), not a top-level block. The downgrade must descend
+   *  into tool_result.contentBlocks and swap the nested image for a note, while
+   *  keeping the tool_result itself intact so tool_use/tool_result pairing
+   *  survives. */
+  test("downgrades an oversized image nested in tool_result.contentBlocks", async () => {
+    // GIVEN an assistant turn whose tool_result holds an oversized screenshot
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(makePngBase64(12000, 9000))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the message is rewritten with the nested image swapped for a note
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    const toolResult = content.find((b) => b.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    // AND the tool_result is preserved (pairing intact) with no image left
+    const nested = (toolResult as { contentBlocks?: ContentBlock[] })
+      .contentBlocks;
+    expect(nested?.some((b) => b.type === "image")).toBe(false);
+    expect(nested?.some((b) => b.type === "text")).toBe(true);
+  });
+
+  /** A sendable nested screenshot is never disturbed. */
+  test("leaves a normally-sized tool_result image untouched", async () => {
+    // GIVEN a tool_result with an image well within provider limits
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(makePngBase64(1024, 768))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing is rewritten and the nested image remains
+    expect(rewritten).toBe(0);
+    const [content] = storedContent(conv.id);
+    const toolResult = content.find((b) => b.type === "tool_result") as {
+      contentBlocks?: ContentBlock[];
+    };
+    expect(toolResult.contentBlocks?.some((b) => b.type === "image")).toBe(
+      true,
+    );
+  });
+
   /** Re-running after a rewrite is a safe no-op (no image blocks remain). */
   test("is idempotent — a second run rewrites nothing", async () => {
     // GIVEN a conversation whose oversized image has already been downgraded
@@ -213,3 +285,27 @@ describe("persistUnsendableImageDowngrades", () => {
     expect(secondRun).toBe(0);
   });
 });
+
+describe("oversizedImageReplacement", () => {
+  /** A still-sendable image must be left alone — never replaced with a note.
+   *  This is the gate that keeps the in-memory recovery from discarding valid
+   *  screenshots when only one image in the turn was actually oversized. */
+  test("returns null for an image within the provider caps", () => {
+    const sendable = imageBlock(makePngBase64(1024, 768)) as Extract<
+      ContentBlock,
+      { type: "image" }
+    >;
+    expect(oversizedImageReplacement(sendable)).toBeNull();
+  });
+
+  /** An image past the provider caps that cannot be shrunk on this host (fake
+   *  PNG that sips cannot decode) collapses to the unsendable note. */
+  test("returns the unsendable note when an oversized image cannot be shrunk", () => {
+    const oversized = imageBlock(makePngBase64(12000, 9000)) as Extract<
+      ContentBlock,
+      { type: "image" }
+    >;
+    const replacement = oversizedImageReplacement(oversized);
+    expect(replacement?.type).toBe("text");
+  });
+});

package/src/__tests__/persistence-secret-redaction.test.ts

@@ -370,3 +370,81 @@ describe("persistence-layer secret redaction", () => {
     expect(textBlock?.text).toBe(text);
   });
 });
+
+describe("thinking timing persistence", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+    state = createEventHandlerState();
+    state.turnStartedAt = 1_700_000_000_000;
+  });
+
+  afterEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  function makeThinkingCompleteEvent(): Extract<
+    AgentEvent,
+    { type: "message_complete" }
+  > {
+    return {
+      type: "message_complete",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "let me reason", signature: "sig" },
+          { type: "text", text: "the answer" },
+        ],
+      },
+    };
+  }
+
+  test("stamps per-block thinking timing onto the persisted thinking block", async () => {
+    // GIVEN a turn whose row was reserved at llm_call_started
+    await handleLlmCallStarted(state, makeDeps());
+
+    // AND streaming then captured timing for one thinking block (startedAt when
+    // it opened, completedAt at its last reasoning delta). The reserve resets
+    // the accumulator, so deltas — and thus the timing — land after it.
+    state.currentThinkingTimestamps = [{ startedAt: 1000, completedAt: 1750 }];
+
+    // WHEN the message completes and content is persisted
+    await handleMessageComplete(state, makeDeps(), makeThinkingCompleteEvent());
+
+    // THEN the persisted thinking block carries the internal `_`-prefixed
+    // timing so a history reload can surface the duration + "Started at" hover
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      _startedAt?: number;
+      _completedAt?: number;
+    }>;
+    const thinkingBlock = blocks.find((b) => b.type === "thinking");
+    expect(thinkingBlock?._startedAt).toBe(1000);
+    expect(thinkingBlock?._completedAt).toBe(1750);
+  });
+
+  test("persists no thinking timing when none was captured this turn", async () => {
+    // GIVEN a turn that produced a thinking block but captured no timing
+    // (thinking streaming disabled, so the timing list stays empty)
+    expect(state.currentThinkingTimestamps).toEqual([]);
+
+    // WHEN the message completes and content is persisted
+    await handleLlmCallStarted(state, makeDeps());
+    await handleMessageComplete(state, makeDeps(), makeThinkingCompleteEvent());
+
+    // THEN the thinking block is persisted without timing, so the client hides
+    // the duration exactly as a tool call with no timing
+    const persisted = lastPersisted("assistant");
+    const blocks = JSON.parse(persisted.content) as Array<{
+      type: string;
+      _startedAt?: number;
+      _completedAt?: number;
+    }>;
+    const thinkingBlock = blocks.find((b) => b.type === "thinking");
+    expect(thinkingBlock).toBeDefined();
+    expect(thinkingBlock?._startedAt).toBeUndefined();
+    expect(thinkingBlock?._completedAt).toBeUndefined();
+  });
+});

package/src/__tests__/plugin-api-shim.test.ts

@@ -34,22 +34,19 @@ describe("buildShimSource", () => {
   test("emits a globalThis trampoline + one binding per export", () => {
     const source = buildShimSource(
       ["foo", "bar"],
-      Symbol.for("vellum.plugin-api.v1"),
+      Symbol.for("vellum.plugin-api"),
     );
     expect(source).toBe(
-      `const api = globalThis[Symbol.for("vellum.plugin-api.v1")];\n` +
+      `const api = globalThis[Symbol.for("vellum.plugin-api")];\n` +
         `export const foo = api.foo;\n` +
         `export const bar = api.bar;\n`,
     );
   });
 
   test("handles an empty export list (today's types-only surface)", () => {
-    const source = buildShimSource(
-      [],
-      Symbol.for("vellum.plugin-api.v1"),
-    );
+    const source = buildShimSource([], Symbol.for("vellum.plugin-api"));
     expect(source).toBe(
-      `const api = globalThis[Symbol.for("vellum.plugin-api.v1")];\n`,
+      `const api = globalThis[Symbol.for("vellum.plugin-api")];\n`,
     );
   });
 });
@@ -109,7 +106,7 @@ describe("ensurePluginApiShim", () => {
     const pluginDir = join(workspaceDir, "plugins", "fake-plugin");
     await mkdir(pluginDir, { recursive: true });
     await writeFile(
-      join(pluginDir, "register.js"),
+      join(pluginDir, "probe.js"),
       `import * as api from "@vellumai/plugin-api";\nexport { api };\n`,
     );
 
@@ -118,7 +115,7 @@ describe("ensurePluginApiShim", () => {
     // → plugin-api namespace. If any link in that chain is broken, this
     // import throws.
     const mod: { api: Record<string, unknown> } = await import(
-      join(pluginDir, "register.js")
+      join(pluginDir, "probe.js")
     );
     expect(mod.api).toBeDefined();
   });