@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/onboarding-template-contract.test.ts

@@ -71,6 +71,8 @@ describe("onboarding template contracts", () => {
 
     test("offers assistant migration during low-signal first openings", () => {
       expect(bootstrap).toContain("## Assistant migration");
+      expect(bootstrap).toContain("onboarding self-introduction");
+      expect(bootstrap).toContain("treat it as the real first user turn");
       expect(bootstrap).toContain(
         "If the first real user turn is only a greeting",
       );

package/src/__tests__/openai-image-service.test.ts

@@ -351,6 +351,23 @@ describe("mapOpenAIError", () => {
     expect(msg).toContain("Rate limit");
   });
 
+  test("maps 402 status to a non-retryable out-of-credits message", () => {
+    const msg = mapOpenAIError(new FakeAPIError(402, "payment required"));
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Please try again");
+  });
+
+  test("maps insufficient_quota (reported as 429) to out-of-credits message", () => {
+    const msg = mapOpenAIError(
+      new FakeAPIError(
+        429,
+        "You exceeded your current quota, please check your plan and billing details. (insufficient_quota)",
+      ),
+    );
+    expect(msg).toContain("out of credits");
+    expect(msg).not.toContain("Rate limit");
+  });
+
   test("maps 500 status to server error message", () => {
     const msg = mapOpenAIError(new FakeAPIError(500, "internal"));
     expect(msg).toContain("temporarily unavailable");

package/src/__tests__/openai-provider.test.ts

@@ -105,7 +105,10 @@ mock.module("openai", () => ({
 import { FireworksProvider } from "../providers/fireworks/client.js";
 import { MinimaxProvider } from "../providers/minimax/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
-import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
+import {
+  EMPTY_ASSISTANT_TURN_PLACEHOLDER,
+  OpenAIChatCompletionsProvider,
+} from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
 import { OpenRouterProvider } from "../providers/openrouter/client.js";
 
@@ -1584,6 +1587,33 @@ describe("OpenRouterProvider reasoning", () => {
     expect(lastCreateParams).not.toHaveProperty("usageAttributionHeaders");
   });
 
+  test("backfills placeholder content for a reasoning-only assistant turn", async () => {
+    const provider = new OpenRouterProvider("or-key", "deepseek/deepseek-chat");
+    await provider.sendMessage([
+      userMsg("question"),
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "truncated reasoning", signature: "" },
+        ],
+      },
+    ]);
+
+    const sent = lastCreateParams!.messages as Array<{
+      role: string;
+      content: string | null;
+      reasoning?: string;
+      tool_calls?: unknown;
+    }>;
+    const assistantMsg = sent.find((m) => m.role === "assistant")!;
+    // DeepSeek via OpenRouter rejects an assistant message with neither content
+    // nor tool_calls, so the reasoning-only turn is backfilled with the sentinel
+    // while the reasoning itself travels in the separate `reasoning` field.
+    expect(assistantMsg.content).toBe(EMPTY_ASSISTANT_TURN_PLACEHOLDER);
+    expect(assistantMsg.tool_calls).toBeUndefined();
+    expect(assistantMsg.reasoning).toBe("truncated reasoning");
+  });
+
   test("RetryProvider + OpenRouterProvider enables thinking end-to-end", async () => {
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
     const retry = new RetryProvider(provider);

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

@@ -0,0 +1,215 @@
+/**
+ * Regression tests for the image-too-large persistence path (JARVIS-1037).
+ *
+ * An image the provider can never accept — over the per-side pixel cap or the
+ * per-image byte cap, and not shrinkable on this host — must be durably swapped
+ * for a text note in its stored message. If it stays in the stored content,
+ * every later turn rehydrates it from the DB and the model reports seeing both
+ * the rejected image and any smaller re-upload. `persistUnsendableImageDowngrades`
+ * makes the swap durable so the rejected upload cannot resurface.
+ *
+ * Uses the real SQLite DB wired up via `test-preload.ts` (per-file temp
+ * workspace).
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+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");
+}
+
+/**
+ * Build a minimal PNG whose IHDR declares the given dimensions. Only the
+ * 8-byte signature and the width/height fields (read by `parseImageDimensions`)
+ * need to be correct; the rest is padding. `optimizeImageForTransport` cannot
+ * downscale this off macOS (no `sips`), so it stays a no-op — exactly the
+ * host condition that produces an unsendable stored image.
+ */
+function makePngBase64(width: number, height: number, padBytes = 0): string {
+  const header = 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, // bit depth / color type / etc.
+    ]),
+  ).toString("base64");
+  return padBytes > 0 ? header + "A".repeat(padBytes) : header;
+}
+
+function imageBlock(data: string): ContentBlock {
+  return {
+    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[],
+  );
+}
+
+const PROVIDER_MAX_IMAGE_DIMENSION = 8000;
+
+describe("persistUnsendableImageDowngrades", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  /** A stored image past the provider pixel cap is swapped for a text note. */
+  test("replaces an oversized image block with a text note", async () => {
+    // GIVEN a message holding text plus an image past the pixel cap
+    const conv = createConversation();
+    const oversized = makePngBase64(PROVIDER_MAX_IMAGE_DIMENSION + 1000, 6000);
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "text", text: "look at this" },
+        imageBlock(oversized),
+      ]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN one message is rewritten with no image block left
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+    // AND the original text is preserved alongside the substituted note
+    expect(content.filter((b) => b.type === "text")).toHaveLength(2);
+  });
+
+  /** The JARVIS-1037 scenario: the rejected original must not resurface next
+   *  to a valid re-upload. */
+  test("re-uploaded smaller image survives while the rejected original is removed", async () => {
+    // GIVEN turn 1 contains an oversized upload that was rejected
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(12000, 9000))]),
+      { skipIndexing: true },
+    );
+    // AND turn 2 contains a properly sized re-upload
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(800, 600))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN only the rejected original is removed
+    expect(rewritten).toBe(1);
+    const [first, second] = storedContent(conv.id);
+    expect(first.some((b) => b.type === "image")).toBe(false);
+    // AND the valid re-upload is left intact
+    expect(second.some((b) => b.type === "image")).toBe(true);
+  });
+
+  /** Sendable images are never disturbed by the recovery path. */
+  test("leaves a normally-sized image untouched", async () => {
+    // GIVEN a message with an image well within provider limits
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(1024, 768))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing is rewritten and the image remains
+    expect(rewritten).toBe(0);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(true);
+  });
+
+  /** The byte-size cap is enforced independently of pixel dimensions. */
+  test("removes an image whose payload exceeds the per-image byte cap", async () => {
+    // GIVEN an image within the pixel cap but with a payload over 5 MB
+    const conv = createConversation();
+    const huge = makePngBase64(1000, 1000, 6 * 1024 * 1024);
+    await addMessage(conv.id, "user", JSON.stringify([imageBlock(huge)]), {
+      skipIndexing: true,
+    });
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the oversized-payload image is removed
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    expect(content.some((b) => b.type === "image")).toBe(false);
+  });
+
+  /** 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
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([imageBlock(makePngBase64(10000, 10000))]),
+      { skipIndexing: true },
+    );
+    expect(persistUnsendableImageDowngrades(conv.id)).toBe(1);
+
+    // WHEN the downgrade runs a second time
+    const secondRun = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing further is rewritten
+    expect(secondRun).toBe(0);
+  });
+});

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

@@ -149,6 +149,7 @@ function makeDeps(): EventHandlerDeps {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   } as EventHandlerDeps;
 }
 

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

@@ -170,12 +170,12 @@ describe("runPipeline — error propagation", () => {
 
     await expect(
       runPipeline(
-        "persistence",
+        "circuitBreaker",
         [thrower],
         terminal,
         { value: 1 },
         makeCtx(),
-        DEFAULT_TIMEOUTS.persistence,
+        DEFAULT_TIMEOUTS.circuitBreaker,
       ),
     ).rejects.toBeInstanceOf(Boom);
   });
@@ -187,12 +187,12 @@ describe("runPipeline — error propagation", () => {
 
     await expect(
       runPipeline(
-        "persistence",
+        "circuitBreaker",
         [],
         terminal,
         { value: 1 },
         makeCtx(),
-        DEFAULT_TIMEOUTS.persistence,
+        DEFAULT_TIMEOUTS.circuitBreaker,
       ),
     ).rejects.toBeInstanceOf(TypeError);
   });
@@ -210,7 +210,7 @@ describe("runPipeline — timeout", () => {
     let caught: unknown;
     try {
       await runPipeline(
-        "memoryRetrieval",
+        "compaction",
         [sleeper],
         terminal,
         { value: 1 },
@@ -223,10 +223,10 @@ describe("runPipeline — timeout", () => {
 
     expect(caught).toBeInstanceOf(PluginTimeoutError);
     const tErr = caught as PluginTimeoutError;
-    expect(tErr.pipeline).toBe("memoryRetrieval");
+    expect(tErr.pipeline).toBe("compaction");
     expect(tErr.pluginName).toBe("slow-plugin");
     expect(tErr.elapsedMs).toBeGreaterThanOrEqual(0);
-    expect(tErr.message).toContain("memoryRetrieval");
+    expect(tErr.message).toContain("compaction");
     expect(tErr.message).toContain("slow-plugin");
   });
 
@@ -235,32 +235,32 @@ describe("runPipeline — timeout", () => {
       value: args.value,
     });
     const result = await runPipeline(
-      "tokenEstimate",
+      "compaction",
       [],
       terminal,
       { value: 42 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.tokenEstimate,
+      DEFAULT_TIMEOUTS.compaction,
     );
     expect(result).toEqual({ value: 42 });
   });
 
   test("null timeout skips the race entirely", async () => {
-    // llmCall has DEFAULT_TIMEOUTS.llmCall === null — runner must not arm a
-    // timer. We verify by completing after an artificial 30ms wait and
-    // confirming success without interference.
+    // compaction has DEFAULT_TIMEOUTS.compaction === null — runner must
+    // not arm a timer. We verify by completing after an artificial 30ms wait
+    // and confirming success without interference.
     const sleeper: Middleware<Args, Result> = async (args, next) =>
       new Promise<Result>((resolve) => {
         setTimeout(() => resolve(next(args)), 30);
       });
     const terminal = async (_args: Args): Promise<Result> => ({ value: 1 });
     const result = await runPipeline(
-      "llmCall",
+      "compaction",
       [sleeper],
       terminal,
       { value: 0 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.llmCall,
+      DEFAULT_TIMEOUTS.compaction,
     );
     expect(result).toEqual({ value: 1 });
   });
@@ -356,7 +356,7 @@ describe("runPipeline — timeout aborts linked signal", () => {
   });
 
   test("args without an AbortSignal property is passed through unchanged", async () => {
-    // Sanity — pipelines that don't carry a signal (persistence, tokenEstimate)
+    // Sanity — pipelines that don't carry a signal (circuitBreaker)
     // see identical args identity as before the abort-linking change.
     const args: Args = { value: 42 };
     let seen: Args | undefined;
@@ -365,12 +365,12 @@ describe("runPipeline — timeout aborts linked signal", () => {
       return { value: innerArgs.value };
     };
     await runPipeline(
-      "persistence",
+      "circuitBreaker",
       [],
       terminal,
       args,
       makeCtx(),
-      DEFAULT_TIMEOUTS.persistence,
+      DEFAULT_TIMEOUTS.circuitBreaker,
     );
     expect(seen).toBe(args);
   });
@@ -428,19 +428,19 @@ describe("runPipeline — structured log record", () => {
 
     await expect(
       runPipeline(
-        "toolError",
+        "circuitBreaker",
         [thrower],
         terminal,
         { value: 1 },
         makeCtx({ pluginName: "noisy-plugin" }),
-        DEFAULT_TIMEOUTS.toolError,
+        DEFAULT_TIMEOUTS.circuitBreaker,
       ),
     ).rejects.toBeInstanceOf(Boom);
 
     expect(fakeLogger.calls.length).toBe(1);
     const [record] = fakeLogger.calls[0]!;
     expect(record.outcome).toBe("error");
-    expect(record.pipeline).toBe("toolError");
+    expect(record.pipeline).toBe("circuitBreaker");
     expect(record.errorName).toBe("BoomError");
     expect(record.errorMessage).toBe("kaboom");
     expect(typeof record.errorStack).toBe("string");
@@ -456,7 +456,7 @@ describe("runPipeline — structured log record", () => {
 
     await expect(
       runPipeline(
-        "emptyResponse",
+        "circuitBreaker",
         [sleeper],
         terminal,
         { value: 1 },
@@ -468,9 +468,9 @@ describe("runPipeline — structured log record", () => {
     expect(fakeLogger.calls.length).toBe(1);
     const [record] = fakeLogger.calls[0]!;
     expect(record.outcome).toBe("timeout");
-    expect(record.pipeline).toBe("emptyResponse");
+    expect(record.pipeline).toBe("circuitBreaker");
     expect(record.errorName).toBe("PluginTimeoutError");
-    expect(String(record.errorMessage)).toContain("emptyResponse");
+    expect(String(record.errorMessage)).toContain("circuitBreaker");
     expect(String(record.errorMessage)).toContain("slow-plugin");
     expect(record.timeoutMs).toBe(15);
     expect(record.pluginName).toBe("slow-plugin");
@@ -481,17 +481,17 @@ describe("runPipeline — structured log record", () => {
       value: args.value,
     });
     await runPipeline(
-      "llmCall",
+      "compaction",
       [],
       terminal,
       { value: 5 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.llmCall,
+      DEFAULT_TIMEOUTS.compaction,
     );
 
     expect(fakeLogger.calls.length).toBe(1);
     const [record] = fakeLogger.calls[0]!;
-    expect(record.pipeline).toBe("llmCall");
+    expect(record.pipeline).toBe("compaction");
     expect(record.outcome).toBe("success");
     expect(record.timeoutMs).toBeUndefined();
   });
@@ -506,7 +506,7 @@ describe("runPipeline — structured log record", () => {
       logger: fakeLogger,
     } as TurnContext;
     await runPipeline(
-      "persistence",
+      "circuitBreaker",
       [],
       terminal,
       { value: 0 },
@@ -531,12 +531,12 @@ describe("runPipeline — structured log record", () => {
       value: args.value,
     });
     await runPipeline(
-      "tokenEstimate",
+      "compaction",
       [a, b, c],
       terminal,
       { value: 0 },
       makeCtx(),
-      DEFAULT_TIMEOUTS.tokenEstimate,
+      DEFAULT_TIMEOUTS.compaction,
     );
     const [record] = fakeLogger.calls[0]!;
     expect(record.chain).toEqual(["outerA", "middleB", "innerC"]);
@@ -546,18 +546,8 @@ describe("runPipeline — structured log record", () => {
 describe("DEFAULT_TIMEOUTS", () => {
   test("matches the design-doc table exactly", () => {
     expect(DEFAULT_TIMEOUTS).toEqual({
-      turn: null,
-      llmCall: null,
-      toolExecute: null,
-      memoryRetrieval: null,
-      tokenEstimate: null,
       compaction: null,
       overflowReduce: null,
-      persistence: null,
-      titleGenerate: null,
-      toolResultTruncate: null,
-      emptyResponse: null,
-      toolError: null,
       circuitBreaker: null,
     });
   });

package/src/__tests__/pkb-autoinject.test.ts

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   getPkbAutoInjectList,
   readAutoinjectList,
-} from "../daemon/conversation-runtime-assembly.js";
+} from "../memory/pkb/autoinject.js";
 
 const PKB_DEFAULT_FILES = [
   "INDEX.md",
@@ -80,10 +80,7 @@ describe("readAutoinjectList", () => {
       "INDEX.md\ncustom-topic.md\n",
       "utf-8",
     );
-    expect(readAutoinjectList(pkbDir)).toEqual([
-      "INDEX.md",
-      "custom-topic.md",
-    ]);
+    expect(readAutoinjectList(pkbDir)).toEqual(["INDEX.md", "custom-topic.md"]);
   });
 
   test("strips blank lines and whitespace", () => {

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

@@ -38,7 +38,6 @@ import { RiskLevel } from "../permissions/types.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
 import {
   closeRegistration,
-  getInjectors,
   getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
@@ -342,8 +341,8 @@ describe("plugin bootstrap", () => {
     // THEN the defaults are still registered, ahead of the user plugin, so the
     // middleware onion order is unchanged
     const names = getRegisteredPlugins().map((p) => p.manifest.name);
-    expect(names).toContain("default-llm-call");
-    expect(names.indexOf("default-llm-call")).toBeLessThan(
+    expect(names).toContain("default-compaction");
+    expect(names.indexOf("default-compaction")).toBeLessThan(
       names.indexOf("user-after-defaults"),
     );
   });
@@ -486,32 +485,22 @@ describe("plugin bootstrap", () => {
     expect(initFired).toBe(false);
   });
 
-  test("requiresFlag disabled: plugin middleware and injectors are dropped from the registry", async () => {
+  test("requiresFlag disabled: plugin middleware is dropped from the registry", async () => {
     // Regression: prior to the unregisterPlugin() call on the flag-gated skip
-    // path, `getMiddlewaresFor()` and `getInjectors()` iterated over every
-    // entry in `registeredPlugins` — so a gated-off plugin's middleware and
-    // injectors still ran on every pipeline invocation and system-prompt
-    // assembly even though `init()` had never fired to set up the state they
-    // depended on.
+    // 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["llmCall"] = async (
+    const gatedMiddleware: PipelineMiddlewareMap["compaction"] = async (
       args,
       next,
     ) => next(args);
     const plugin = buildPlugin(
       "gated-middleware",
       {
-        middleware: { llmCall: gatedMiddleware },
-        injectors: [
-          {
-            name: "gated-middleware-injector",
-            order: 100,
-            async produce() {
-              return null;
-            },
-          },
-        ],
+        middleware: { compaction: gatedMiddleware },
       },
       { requiresFlag: ["plugin-middleware-disabled"] },
     );
@@ -519,14 +508,10 @@ describe("plugin bootstrap", () => {
 
     await bootstrapPlugins();
 
-    // Neither the middleware slot nor the injector list should expose the
-    // flag-gated plugin's contributions. The default plugins also contribute
-    // llmCall middleware / injectors, so we key on identity rather than
-    // asserting empty lists.
-    expect(getMiddlewaresFor("llmCall")).not.toContain(gatedMiddleware);
-    expect(
-      getInjectors().some((i) => i.name === "gated-middleware-injector"),
-    ).toBe(false);
+    // 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);
   });
 
   test("requiresFlag disabled: no shutdown hook entry installed for the skipped plugin", async () => {

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

@@ -10,7 +10,6 @@ import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   closeRegistration,
-  getInjectors,
   getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
@@ -19,7 +18,6 @@ import {
 import {
   type CompactionArgs,
   type CompactionResult,
-  type Injector,
   type Middleware,
   type Plugin,
   PluginExecutionError,
@@ -149,31 +147,6 @@ describe("plugin registry", () => {
     expect(() => registerPlugin(bad)).toThrow(/manifest\.version is required/);
   });
 
-  test("getInjectors returns injectors sorted by order ascending", () => {
-    const high: Injector = {
-      name: "high-order",
-      order: 20,
-      async produce() {
-        return null;
-      },
-    };
-    const low: Injector = {
-      name: "low-order",
-      order: 10,
-      async produce() {
-        return null;
-      },
-    };
-
-    // Register the higher-order plugin first so registration order alone
-    // would produce the wrong sequence — the test proves sort-by-order wins.
-    registerPlugin(buildPlugin("high", { injectors: [high] }));
-    registerPlugin(buildPlugin("low", { injectors: [low] }));
-
-    const injectors = getInjectors();
-    expect(injectors.map((i) => i.name)).toEqual(["low-order", "high-order"]);
-  });
-
   test("getMiddlewaresFor returns middleware in registration order", () => {
     const firstMw: Middleware<CompactionArgs, CompactionResult> = async (
       args,