@vellumai/assistant 0.8.7-dev.202606052118.34cd356 → 0.8.7-dev.202606052220.6efc86d

package/examples/plugins/echo/README.md

@@ -1,46 +1,59 @@
 # Echo plugin
 
-Minimal example plugin. Observes every assistant pipeline and logs one JSON
-line per invocation to `stderr`:
+Minimal example plugin. Observes the assistant's turn-lifecycle hooks and logs
+one JSON line per hook invocation to `stderr`:
 
 ```json
 {
   "plugin": "echo",
-  "pipeline": "compaction",
-  "durationMs": 1590,
-  "outcome": "success"
+  "hook": "post-tool-use",
+  "conversationId": "conv_abc123"
 }
 ```
 
 Use this as a starting point for writing your own plugin, or as a quick way
-to eyeball which pipelines fire during a conversation and how long they
-take.
+to eyeball which hooks fire during a conversation.
 
-For the full plugin authoring guide, see
-[`assistant/docs/plugins.md`](../../../docs/plugins.md).
+For the full plugin authoring guide — manifest shape, every contribution
+surface, hook patterns, and conventions — see
+[`experimental/plugins/README.md`](../../../../experimental/plugins/README.md).
+[`simple-memory`](../../../../experimental/plugins/simple-memory/) is the
+canonical reference implementation that exercises every wired surface.
 
 ## What it does
 
-- Registers one observer middleware per slot in
-  `PipelineMiddlewareMap` — `compaction`.
-- Each middleware calls `next(args)` to pass the request through unchanged,
-  measures wall-clock duration, and emits one line to `stderr` whether the
-  downstream succeeded or threw.
-- Never modifies arguments, never rewrites results, never swallows errors.
-  It is purely observational — safe to stack alongside any other plugin.
+- Contributes one observer hook per turn-lifecycle event:
+  `user-prompt-submit`, `post-tool-use`, and `stop`.
+- Each hook emits one line to `stderr` and returns `void`, so the threaded
+  context flows through unchanged.
+- Never modifies the turn's messages, tool results, or stop decision. It is
+  purely observational — safe to stack alongside any other plugin.
+
+## Directory layout
+
+The assistant discovers a plugin by its `package.json` manifest and builds the
+`Plugin` from the interface directories — `hooks/<name>.ts` files whose default
+export is the hook function. Files under `src/` are internal helpers and are
+not walked by the loader.
+
+```
+echo/
+├── package.json               # Manifest (name + @vellumai/plugin-api range)
+├── README.md
+├── hooks/
+│   ├── user-prompt-submit.ts  # default export = hook function
+│   ├── post-tool-use.ts
+│   └── stop.ts
+└── src/
+    └── emit.ts                # shared stderr emitter (not a surface)
+```
 
 ## Install locally
 
 The assistant scans `<workspaceDir>/plugins/*` (e.g.
-`~/.vellum/workspace/plugins/`) for subdirectories containing a
-`register.{ts,js}` file and dynamic-imports each one during assistant
-startup. Dropping (or symlinking) this directory in place is enough to
-enable it.
-
-The plugin reads `registerPlugin` from `globalThis.__vellumPluginRuntime`,
-which the daemon attaches before scanning plugins. This works against both
-the `bun --compile`-bundled daemon binary AND a daemon running from
-source — no special install procedure required either way.
+`~/.vellum/workspace/plugins/`) for subdirectories containing a `package.json`
+and loads each one during assistant startup. Dropping (or symlinking) this
+directory in place is enough to enable it.
 
 ### Option 1 — symlink from the repo (simplest in-repo dev)
 
@@ -57,23 +70,10 @@ pick up changes.
 ### Option 2 — standalone copy
 
 A plain `cp -R` of this directory into `~/.vellum/workspace/plugins/echo/`
-works for the runtime imports (which go through the global bridge), but
-the `import type` lines at the top of `register.ts` still resolve into
-the in-repo assistant source tree. If your standalone copy lives outside
-a vellum-assistant checkout, rewrite those `import type` paths to point
-at an absolute path inside any checkout — they're erased at compile time
-and have no module-identity effect at runtime:
-
-```ts
-// before (repo-local):
-import type { VellumPluginRuntime } from "../../../src/plugins/external-api.js";
-import type { Plugin } from "../../../src/plugins/types.js";
-// after (standalone, edit to your checkout path):
-import type { VellumPluginRuntime } from "/path/to/vellum-assistant/assistant/src/plugins/external-api.js";
-import type { Plugin } from "/path/to/vellum-assistant/assistant/src/plugins/types.js";
-```
-
-No runtime-import rewriting is needed — the bridge already handles that.
+works as-is. The hooks import their types from the public `@vellumai/plugin-api`
+specifier, which the daemon materializes as a workspace-level shim before it
+loads any plugin — so the copied directory resolves it without any path
+rewriting, in or out of a vellum-assistant checkout.
 
 ### Restart the assistant
 
@@ -87,28 +87,23 @@ vellum restart
 ## Verify it works
 
 With the plugin installed and the assistant restarted, send any message
-that exercises a pipeline — a conversation turn, a tool call, a title
-generation — and tail the assistant's stderr log:
+that exercises a turn — a conversation reply, a tool call — and tail the
+assistant's stderr log:
 
 ```bash
 tail -f ~/.vellum/daemon.log
 ```
 
-You should see one line per pipeline invocation, similar to:
+You should see one line per hook invocation, similar to:
 
 ```json
 {
   "plugin": "echo",
-  "pipeline": "compaction",
-  "durationMs": 1590,
-  "outcome": "success"
+  "hook": "post-tool-use",
+  "conversationId": "conv_abc123"
 }
 ```
 
-If a pipeline throws (for example, a tool that errors out), you'll see a
-line with `"outcome":"error"` — the plugin rethrows after logging so the
-original error still propagates.
-
 ## Uninstall
 
 Remove the symlink (or the copied directory) and restart the assistant:
@@ -120,14 +115,13 @@ vellum restart
 
 ## Next steps
 
-- Read [`assistant/docs/plugins.md`](../../../docs/plugins.md) for the full
-  plugin authoring guide: manifest shape, middleware patterns
-  (observe / transform / short-circuit / veto), strict-fail semantics, the
-  per-pipeline timeout table, credential and config access, and
-  troubleshooting.
+- Read [`experimental/plugins/README.md`](../../../../experimental/plugins/README.md)
+  for the full plugin authoring guide: manifest shape, every contribution
+  surface, hook patterns (observe / transform), tool contributions, and
+  conventions.
 - Look at the first-party default plugins under
-  `assistant/src/plugins/defaults/` for examples of non-observational
-  middleware.
+  `assistant/src/plugins/defaults/` for examples of hooks that transform a
+  turn rather than just observing it.
 - Build your own plugin by copying this directory, renaming the manifest
-  `name`, and replacing the observer with a middleware that does whatever
-  you need.
+  `name`, and replacing the observer hooks with ones that do whatever you
+  need.

package/examples/plugins/echo/hooks/post-tool-use.ts

@@ -0,0 +1,18 @@
+/**
+ * `post-tool-use` hook for the echo plugin.
+ *
+ * Purely observational — logs one structured line to stderr and returns
+ * `void`, leaving the tool result untouched.
+ *
+ * Convention: the default export is the function the harness invokes.
+ */
+
+import type { PostToolUseContext } from "@vellumai/plugin-api";
+
+import { emit } from "../src/emit.js";
+
+export default async function postToolUse(
+  ctx: PostToolUseContext,
+): Promise<void> {
+  emit("post-tool-use", ctx.conversationId);
+}

package/examples/plugins/echo/hooks/stop.ts

@@ -0,0 +1,16 @@
+/**
+ * `stop` hook for the echo plugin.
+ *
+ * Purely observational — logs one structured line to stderr and returns
+ * `void`, leaving the stop decision untouched.
+ *
+ * Convention: the default export is the function the harness invokes.
+ */
+
+import type { StopContext } from "@vellumai/plugin-api";
+
+import { emit } from "../src/emit.js";
+
+export default async function stop(ctx: StopContext): Promise<void> {
+  emit("stop", ctx.conversationId);
+}

package/examples/plugins/echo/hooks/user-prompt-submit.ts

@@ -0,0 +1,18 @@
+/**
+ * `user-prompt-submit` hook for the echo plugin.
+ *
+ * Purely observational — logs one structured line to stderr and returns
+ * `void`, leaving the threaded context (message list, injections) untouched.
+ *
+ * Convention: the default export is the function the harness invokes.
+ */
+
+import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
+
+import { emit } from "../src/emit.js";
+
+export default async function userPromptSubmit(
+  ctx: UserPromptSubmitContext,
+): Promise<void> {
+  emit("user-prompt-submit", ctx.conversationId);
+}

package/examples/plugins/echo/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@vellumai/plugin-echo-example",
   "version": "0.1.0",
-  "description": "Example plugin that observes every assistant pipeline and logs one structured line per invocation to stderr. Meant as an authoring reference — not shipped with the assistant runtime.",
+  "description": "Example plugin that observes every assistant turn-lifecycle hook and logs one structured line per invocation to stderr. Meant as an authoring reference — not shipped with the assistant runtime.",
   "private": true,
   "license": "MIT",
   "type": "module",
-  "main": "./register.ts",
   "engines": {
     "node": ">=20.12.0"
   },

package/examples/plugins/echo/src/emit.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared stderr emitter for the echo plugin's hooks.
+ *
+ * Files under `src/` are internal helpers — the external-plugin loader does
+ * not walk this directory, so it contributes no surface of its own. The
+ * `hooks/` files import from here.
+ */
+
+export const PLUGIN_NAME = "echo";
+
+/**
+ * One line written to stderr per hook invocation. Kept intentionally compact —
+ * pino-style JSON so operators can pipe the assistant's stderr through `jq`
+ * without reshaping.
+ */
+export function emit(hook: string, conversationId: string): void {
+  const record = { plugin: PLUGIN_NAME, hook, conversationId };
+  process.stderr.write(`${JSON.stringify(record)}\n`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.7-dev.202606052118.34cd356",
+  "version": "0.8.7-dev.202606052220.6efc86d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -122,6 +122,7 @@ function seedActiveSurfaceConversation(
   surfaceId: string,
   data: SurfaceData,
   channelCapabilities?: ChannelCapabilities,
+  commandIntent?: { type: string; payload?: string; languageCode?: string },
 ): void {
   setConversation(conversationId, {
     conversationId,
@@ -134,6 +135,7 @@ function seedActiveSurfaceConversation(
       { surfaceType: SurfaceType; data: SurfaceData }
     >([[surfaceId, { surfaceType: "dynamic_page", data }]]),
     channelCapabilities: channelCapabilities ?? undefined,
+    commandIntent,
   } as never);
 }
 
@@ -149,6 +151,7 @@ function clearWorkspaceContext(): void {
 // between tests keeps suites asserting absence unaffected.
 function seedChannelCapabilitiesConversation(
   caps: ChannelCapabilities | null,
+  transportHints?: string[],
 ): void {
   setConversation("runtime-assembly-fallback", {
     conversationId: "runtime-assembly-fallback",
@@ -157,6 +160,7 @@ function seedChannelCapabilitiesConversation(
     workspaceTopLevelDirty: false,
     surfaceState: new Map(),
     channelCapabilities: caps ?? undefined,
+    transportHints,
   } as never);
 }
 
@@ -819,7 +823,6 @@ describe("applyRuntimeInjections — injection mode", () => {
   };
 
   const fullOptions = {
-    channelCommandContext: { type: "start" } as const,
     unifiedTurnContext:
       "<turn_context>\ncurrent_time: 2026-03-04 (Tuesday) 12:00:00 +00:00 (UTC)\ninterface: telegram\n</turn_context>",
     isNonInteractive: true,
@@ -849,6 +852,7 @@ describe("applyRuntimeInjections — injection mode", () => {
       "sf_1",
       { html: "<div>test</div>" },
       channelCapabilities,
+      { type: "start" },
     );
   });
   afterEach(() => {
@@ -3044,12 +3048,13 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       { loader: () => rows, trustClass: "guardian" },
     );
 
-    seedChannelCapabilitiesConversation(slackChannelCaps);
+    seedChannelCapabilitiesConversation(slackChannelCaps, [
+      "thread context: ...",
+    ]);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "current turn" }] }],
       {
         slackChronologicalMessages,
-        transportHints: ["thread context: ..."],
       },
     );
 
@@ -3074,12 +3079,10 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       chatType: "im",
     };
 
-    seedChannelCapabilitiesConversation(slackDmCaps);
+    seedChannelCapabilitiesConversation(slackDmCaps, ["dm context: ..."]);
     const { messages: result } = await applyRuntimeInjections(
       [{ role: "user", content: [{ type: "text", text: "hi DM" }] }],
-      {
-        transportHints: ["dm context: ..."],
-      },
+      {},
     );
 
     const allText = result
@@ -3093,18 +3096,19 @@ describe("Slack channel chronological rendering — multi-thread", () => {
 
   // ── transport_hints kept for non-slack channels ───────────────────────
   test("non-slack conversations still receive <transport_hints>", async () => {
-    seedChannelCapabilitiesConversation({
-      channel: "telegram",
-      dashboardCapable: false,
-      supportsDynamicUi: false,
-      supportsVoiceInput: false,
-      chatType: "private",
-    });
-    const { messages: result } = await applyRuntimeInjections(
-      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+    seedChannelCapabilitiesConversation(
       {
-        transportHints: ["please answer concisely"],
+        channel: "telegram",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "private",
       },
+      ["please answer concisely"],
+    );
+    const { messages: result } = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {},
     );
     const allText = result
       .flatMap((m) => m.content)

package/src/__tests__/gateway-only-guard.test.ts

@@ -27,6 +27,7 @@ const ALLOWLIST = new Set([
   "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
+  "apps/macos/src/main/bundle-flow.ts", // Electron main calls the local gateway (gatewayPort) with a Guardian token to scan bundles
   ".claude/skills/update/SKILL.md", // daemon health check script
 
   // --- Test fixtures that poll the daemon directly (gateway may require auth) ---
@@ -84,12 +85,21 @@ function isGatewayInternal(filePath: string): boolean {
   return filePath.startsWith("gateway/");
 }
 
+/** Additional files allowed for the interpolated-port check only (use gateway port, not runtime). */
+const INTERPOLATED_PORT_ALLOWLIST = new Set([
+  "apps/macos/src/main/bundle-flow.ts",
+]);
+
 /** Shared violation filter: exempt test files, gateway internals, and allowlisted paths. */
-function filterViolations(files: string[]): string[] {
+function filterViolations(
+  files: string[],
+  extraAllowlist?: Set<string>,
+): string[] {
   return files.filter((f) => {
     if (isTestFile(f)) return false;
     if (isGatewayInternal(f)) return false;
     if (ALLOWLIST.has(f)) return false;
+    if (extraAllowlist?.has(f)) return false;
     return true;
   });
 }
@@ -181,7 +191,7 @@ describe("gateway-only API consumption guard", () => {
     }
 
     const files = grepOutput.split("\n").filter((f) => f.length > 0);
-    const violations = filterViolations(files);
+    const violations = filterViolations(files, INTERPOLATED_PORT_ALLOWLIST);
 
     if (violations.length > 0) {
       const message = [

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

@@ -44,10 +44,7 @@ describe("buildShimSource", () => {
   });
 
   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.v1"));
     expect(source).toBe(
       `const api = globalThis[Symbol.for("vellum.plugin-api.v1")];\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 () => {

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

@@ -2,26 +2,19 @@
  * Tests for the plugin registry (PR 13).
  *
  * Covers successful registration, required-field and duplicate-name
- * validation, capability-version negotiation error messaging, injector
- * ordering, and middleware collection order.
+ * validation, capability-version negotiation error messaging, and
+ * registration order.
  */
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   closeRegistration,
-  getMiddlewaresFor,
   getRegisteredPlugins,
   registerPlugin,
   resetPluginRegistryForTests,
 } from "../plugins/registry.js";
-import {
-  type CompactionArgs,
-  type CompactionResult,
-  type Middleware,
-  type Plugin,
-  PluginExecutionError,
-} from "../plugins/types.js";
+import { type Plugin, PluginExecutionError } from "../plugins/types.js";
 
 /** Build a minimal, valid plugin with the given name and optional extras. */
 function buildPlugin(
@@ -147,45 +140,6 @@ describe("plugin registry", () => {
     expect(() => registerPlugin(bad)).toThrow(/manifest\.version is required/);
   });
 
-  test("getMiddlewaresFor returns middleware in registration order", () => {
-    const firstMw: Middleware<CompactionArgs, CompactionResult> = async (
-      args,
-      next,
-    ) => next(args);
-    const secondMw: Middleware<CompactionArgs, CompactionResult> = async (
-      args,
-      next,
-    ) => next(args);
-
-    registerPlugin(
-      buildPlugin("plugin-first", { middleware: { compaction: firstMw } }),
-    );
-    registerPlugin(
-      buildPlugin("plugin-second", { middleware: { compaction: secondMw } }),
-    );
-
-    const middlewares = getMiddlewaresFor("compaction");
-    expect(middlewares).toHaveLength(2);
-    // Identity comparison proves the middleware instances come back in
-    // registration order — outer→inner composition semantics belong to the
-    // pipeline runner (PR 12), not the registry.
-    expect(middlewares[0]).toBe(firstMw);
-    expect(middlewares[1]).toBe(secondMw);
-  });
-
-  test("getMiddlewaresFor skips plugins without a middleware for the pipeline", () => {
-    const mw: Middleware<CompactionArgs, CompactionResult> = async (
-      args,
-      next,
-    ) => next(args);
-    registerPlugin(buildPlugin("bare"));
-    registerPlugin(buildPlugin("has-mw", { middleware: { compaction: mw } }));
-
-    const middlewares = getMiddlewaresFor("compaction");
-    expect(middlewares).toHaveLength(1);
-    expect(middlewares[0]).toBe(mw);
-  });
-
   test("getRegisteredPlugins reflects registration order", () => {
     registerPlugin(buildPlugin("one"));
     registerPlugin(buildPlugin("two"));

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

@@ -13,14 +13,10 @@ import { describe, expect, test } from "bun:test";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { RiskLevel } from "../permissions/types.js";
 import {
-  type CompactionArgs,
-  type CompactionResult,
-  type Middleware,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
   type PluginManifest,
-  PluginTimeoutError,
   type TurnContext,
 } from "../plugins/types.js";
 import type { Tool } from "../tools/types.js";
@@ -34,7 +30,6 @@ const sampleTurnContext: TurnContext = {
   requestId: "req-abc",
   conversationId: "conv-xyz",
   turnIndex: 0,
-  pluginName: "sample-plugin",
   trust: sampleTrust,
 };
 
@@ -48,14 +43,6 @@ describe("plugin core types", () => {
       config: { parse: (input: unknown) => input },
     };
 
-    // The `compaction` slot has a concrete arg/result shape, so it needs a
-    // dedicated passthrough whose middleware signature matches — keeping the
-    // shape-only `satisfies Plugin` assertion meaningful for the slot.
-    const compactionPassthrough: Middleware<
-      CompactionArgs,
-      CompactionResult
-    > = async (args, next, _ctx) => next(args);
-
     const sampleTool: Tool = {
       name: "sample-tool",
       description: "Sample plugin tool",
@@ -99,32 +86,10 @@ describe("plugin core types", () => {
           body: "## Sample\n\nPlugin-provided skill body.",
         },
       ],
-      middleware: {
-        compaction: compactionPassthrough,
-      },
     } satisfies Plugin;
 
     // Minimal runtime check so the test body is non-empty.
     expect(plugin.manifest.name).toBe("sample-plugin");
-    expect(plugin.middleware.compaction).toBe(compactionPassthrough);
-  });
-
-  test("PluginTimeoutError carries pipeline, plugin, and elapsed fields", () => {
-    const err = new PluginTimeoutError("compaction", "sample-plugin", 30000);
-    expect(err).toBeInstanceOf(Error);
-    expect(err.name).toBe("PluginTimeoutError");
-    expect(err.pipeline).toBe("compaction");
-    expect(err.pluginName).toBe("sample-plugin");
-    expect(err.elapsedMs).toBe(30000);
-    expect(err.message).toContain("compaction");
-    expect(err.message).toContain("30000");
-    expect(err.message).toContain("sample-plugin");
-  });
-
-  test("PluginTimeoutError omits plugin suffix when unknown", () => {
-    const err = new PluginTimeoutError("compaction", undefined, 1234);
-    expect(err.pluginName).toBeUndefined();
-    expect(err.message).not.toContain("offending plugin");
   });
 
   test("PluginExecutionError carries the plugin name and message", () => {