@vellumai/assistant 0.8.8 → 0.8.9-staging.1

package/src/__tests__/injector-v3-suppression.test.ts

@@ -110,7 +110,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // Exactly one <memory> source across the WHOLE assembled context.
@@ -149,7 +149,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // v2's block survives — the turn still ships memory.
@@ -177,7 +177,7 @@ describe("memory-v3-live v2 suppression", () => {
     // captures the exact pre-flag assembly behavior: v2 prefix stays, v3
     // splices after it.
     const offResult = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // The tail keeps v2's block AND gains v3's (the historical double-injection
@@ -206,7 +206,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     expect(result.messages).toEqual(runMessages);

package/src/__tests__/list-messages-client-message-id.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for handleListMessages clientMessageId projection.
+ *
+ * Verifies that the persisted idempotency nonce is echoed back on the
+ * messages snapshot row so a client can correlate its optimistic row with
+ * the confirmed server row by identity instead of matching message text.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface MessagePayload {
+  role: string;
+  clientMessageId?: string;
+}
+
+describe("handleListMessages clientMessageId", () => {
+  beforeEach(resetTables);
+
+  test("echoes the persisted clientMessageId onto the user row", async () => {
+    // GIVEN a user message persisted with a client-generated idempotency nonce
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+      { clientMessageId: "nonce-abc", skipIndexing: true },
+    );
+
+    // WHEN the messages snapshot is built
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the snapshot row carries the nonce back for id-based correlation
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].role).toBe("user");
+    expect(body.messages[0].clientMessageId).toBe("nonce-abc");
+  });
+
+  test("omits clientMessageId when the row was persisted without one", async () => {
+    // GIVEN a user message persisted without a client nonce (e.g. a channel send)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the messages snapshot is built
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the field is absent rather than emitted as null/empty
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].clientMessageId).toBeUndefined();
+  });
+});

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -96,6 +96,44 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(llmRows[1].metadata).toContain('"hidden":true');
   });
 
+  test("UI serializer omits system rows but LLM-side getMessages includes them", async () => {
+    // GIVEN a conversation with a system row sandwiched between two
+    // renderable turns (e.g. a skill-authored context message)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "first visible" }]),
+    );
+    await addMessage(
+      conv.id,
+      "system",
+      JSON.stringify([{ type: "text", text: "system scaffolding" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "second visible" }]),
+    );
+
+    // WHEN the UI history list is serialized
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN only the user/assistant turns are returned, never the system row
+    expect(body.messages.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      body.messages.some((m) => plainText(m).includes("system scaffolding")),
+    ).toBe(false);
+
+    // AND the LLM-side loader still includes the system row for agent context
+    const llmRows = getMessages(conv.id);
+    expect(llmRows).toHaveLength(3);
+    expect(llmRows[1].role).toBe("system");
+  });
+
   test("messages without metadata or with hidden=false are returned", async () => {
     const conv = createConversation();
     await addMessage(

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -1,12 +1,15 @@
 /**
- * Tests for the default `user-prompt-submit-temp` hook (memory retrieval).
+ * Tests for the default `user-prompt-submit-temp` hook (memory retrieval +
+ * runtime injection).
  *
  * Covers the retrieval behavior, the side effects the hook owns (injected-block
- * metadata, recall log, `memory_recalled` event), trust gating, error
- * propagation, and abort-signal forwarding. Uses `mock.module` to stub the
- * persistence helpers so the test doesn't touch the developer's real
- * `~/.vellum` or database. The memory graph handle is a hand-rolled fake
- * passed on the hook context — the hook only needs `prepareMemory`.
+ * metadata, recall log, `memory_recalled` event), trust gating, the runtime
+ * injection the hook applies for every actor (and the assembled-block persist),
+ * error propagation, and abort-signal forwarding. Uses `mock.module` to stub
+ * the persistence helpers and `applyRuntimeInjections` so the test doesn't touch
+ * the developer's real `~/.vellum`, database, or live conversation state. The
+ * memory graph handle is a hand-rolled fake passed on the hook context — the
+ * hook only needs `prepareMemory`.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -23,6 +26,17 @@ mock.module("../memory/memory-recall-log-store.js", () => ({
   recordMemoryRecallLog: recordMemoryRecallLogMock,
 }));
 
+// Pass-through injection stub: returns the input messages unchanged with no
+// assembled blocks, so existing array-identity assertions hold. Individual
+// tests override it via `mockImplementationOnce` to exercise injected blocks.
+const applyRuntimeInjectionsMock = mock(async (messages: unknown) => ({
+  messages,
+  blocks: {},
+}));
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
+  applyRuntimeInjections: applyRuntimeInjectionsMock,
+}));
+
 import type { AssistantConfig } from "../config/schema.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
@@ -117,6 +131,11 @@ function makeHookCtx(
     } as unknown as MemoryRetrievalHookContext["logger"],
     signal: new AbortController().signal,
     latestMessages: [],
+    requestId: "req-test",
+    mode: "full",
+    isNonInteractive: false,
+    modelProfile: null,
+    actorContext: null,
     ...overrides,
   };
 }
@@ -124,6 +143,7 @@ function makeHookCtx(
 beforeEach(() => {
   updateMessageMetadataMock.mockReset();
   recordMemoryRecallLogMock.mockReset();
+  applyRuntimeInjectionsMock.mockClear();
 });
 
 describe("user-prompt-submit-temp hook (memory retrieval)", () => {
@@ -177,6 +197,53 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     );
   });
 
+  test("applies runtime injection on the retrieved history and persists the assembled blocks", async () => {
+    const retrieved: Message[] = [
+      { role: "user", content: [{ type: "text", text: "retrieved" }] },
+    ];
+    const injected: Message[] = [
+      { role: "user", content: [{ type: "text", text: "injected" }] },
+    ];
+    const { memory } = makeFakeGraphMemory({ messages: retrieved });
+    applyRuntimeInjectionsMock.mockImplementationOnce(async () => ({
+      messages: injected,
+      blocks: { unifiedTurnContext: "tc-block" },
+    }));
+    const ctx = makeHookCtx({ graphMemory: memory, userMessageId: "msg-77" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    // Injection runs on the retrieved history; its result becomes the working
+    // list the loop reads back.
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+    expect(applyRuntimeInjectionsMock.mock.calls[0]?.[0]).toBe(retrieved);
+    expect(ctx.latestMessages).toBe(injected);
+    // The assembled blocks are persisted onto the user message metadata.
+    expect(updateMessageMetadataMock).toHaveBeenCalledWith("msg-77", {
+      turnContextBlock: "tc-block",
+    });
+  });
+
+  test("applies runtime injection for untrusted actors despite skipping retrieval", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    const seeded: Message[] = [
+      { role: "user", content: [{ type: "text", text: "seeded" }] },
+    ];
+    const ctx = makeHookCtx({
+      graphMemory: memory,
+      isTrustedActor: false,
+      latestMessages: seeded,
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    // The memory-graph step is gated on trust, but injection runs for everyone
+    // — on the seeded history, since no retrieval replaced it.
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+    expect(applyRuntimeInjectionsMock.mock.calls[0]?.[0]).toBe(seeded);
+  });
+
   test("skips graph retrieval and side effects for untrusted actors", async () => {
     const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
       makeFakeGraphMemory();

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__/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__/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();
   });

package/src/__tests__/plugin-bootstrap.test.ts

@@ -38,13 +38,11 @@ import { RiskLevel } from "../permissions/types.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
 import {
   closeRegistration,
-  getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
 import {
-  type PipelineMiddlewareMap,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
@@ -485,33 +483,24 @@ describe("plugin bootstrap", () => {
     expect(initFired).toBe(false);
   });
 
-  test("requiresFlag disabled: plugin middleware is dropped from the registry", async () => {
-    // Regression: prior to the unregisterPlugin() call on the flag-gated skip
-    // path, `getMiddlewaresFor()` iterated over every entry in
-    // `registeredPlugins` — so a gated-off plugin's middleware still ran on
-    // every pipeline invocation even though `init()` had never fired to set up
-    // the state it depended on.
-    setOverridesForTesting({ "plugin-middleware-disabled": false });
-
-    const gatedMiddleware: PipelineMiddlewareMap["compaction"] = async (
-      args,
-      next,
-    ) => next(args);
+  test("requiresFlag disabled: the skipped plugin is removed from the registry", async () => {
+    // Regression: a flag-gated skip must call `unregisterPlugin()` so the
+    // gated-off plugin does not linger in `registeredPlugins` with its
+    // `init()` never having fired to set up the state it depends on.
+    setOverridesForTesting({ "plugin-registry-disabled": false });
+
     const plugin = buildPlugin(
-      "gated-middleware",
-      {
-        middleware: { compaction: gatedMiddleware },
-      },
-      { requiresFlag: ["plugin-middleware-disabled"] },
+      "gated-registry",
+      {},
+      { requiresFlag: ["plugin-registry-disabled"] },
     );
     registerPlugin(plugin);
 
     await bootstrapPlugins();
 
-    // The middleware slot must not expose the flag-gated plugin's contribution.
-    // The default plugins also contribute compaction middleware, so we key on
-    // identity rather than asserting an empty list.
-    expect(getMiddlewaresFor("compaction")).not.toContain(gatedMiddleware);
+    // The gated-off plugin must not survive in the registry snapshot.
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("gated-registry");
   });
 
   test("requiresFlag disabled: no shutdown hook entry installed for the skipped plugin", async () => {