@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091853.fbaa2ae

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

@@ -38,17 +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,
-} from "../plugins/types.js";
+import { type Plugin, type PluginInitContext } from "../plugins/types.js";
 import { APP_VERSION } from "../version.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
@@ -176,9 +170,9 @@ describe("plugin bootstrap", () => {
     expect(received?.credentials).toEqual({ "some-key": "super-secret-value" });
   });
 
-  test("credential resolution: missing credential fails bootstrap with the plugin named", async () => {
+  test("credential resolution: a plugin whose required credential is missing is skipped, not fatal", async () => {
+    // GIVEN a plugin that requires a credential the store cannot resolve
     getSecureKeyAsyncMock.mockImplementation(async () => undefined);
-
     registerPlugin(
       buildPlugin(
         "missing-cred",
@@ -187,16 +181,14 @@ describe("plugin bootstrap", () => {
       ),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("missing-cred");
-    expect(msg).toContain("absent-key");
+    // WHEN bootstrap runs
+    // THEN it completes without throwing — the unresolvable credential is
+    // contained to that plugin (same per-plugin isolation as an init throw)
+    await bootstrapPlugins();
+
+    // AND the plugin is dropped from the registry
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("missing-cred");
   });
 
   test("version mismatch: external plugin loader rejects when peerDependency unsatisfied", async () => {
@@ -210,7 +202,8 @@ describe("plugin bootstrap", () => {
     expect(() => registerPlugin(plugin)).not.toThrow();
   });
 
-  test("plugin init throw: bootstrap throws a PluginExecutionError naming the plugin", async () => {
+  test("plugin init throw: bootstrap contains the failure and does not throw", async () => {
+    // GIVEN a plugin whose init throws
     registerPlugin(
       buildPlugin("broken", {
         async init() {
@@ -219,65 +212,91 @@ describe("plugin bootstrap", () => {
       }),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("broken");
-    expect(msg).toContain("kaboom");
+    // WHEN bootstrap runs
+    // THEN it completes without throwing — a single plugin's init failure is
+    // contained to that plugin rather than aborting the whole plugin layer
+    await bootstrapPlugins();
+
+    // AND the failing plugin is dropped from the registry so its hooks never
+    // participate in the turn lifecycle
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("broken");
   });
 
-  test("partial-init failure: earlier plugins' onShutdown runs in reverse before the error propagates", async () => {
-    // If plugin N throws during init, every plugin 1..N-1 that already made
-    // it through its full init+contribution phase must have onShutdown()
-    // invoked in reverse registration order before bootstrap re-throws.
-    // Without this, earlier plugins leak live tools/routes/skills because
-    // the shutdown hook is only registered once the entire loop completes.
-    const callOrder: string[] = [];
+  test("mid-list init failure: surrounding plugins still initialize and survive", async () => {
+    // GIVEN two healthy plugins surrounding one whose init throws, registered
+    // in order
+    const initialized: string[] = [];
+    const shutDownDuringBootstrap: string[] = [];
     registerPlugin(
-      buildPlugin("survivor-a", {
-        async init() {},
+      buildPlugin("before", {
+        async init() {
+          initialized.push("before");
+        },
         async onShutdown() {
-          callOrder.push("survivor-a");
+          shutDownDuringBootstrap.push("before");
         },
       }),
     );
     registerPlugin(
-      buildPlugin("survivor-b", {
-        async init() {},
-        async onShutdown() {
-          callOrder.push("survivor-b");
+      buildPlugin("failing", {
+        async init() {
+          throw new Error("mid-bootstrap failure");
         },
       }),
     );
     registerPlugin(
-      buildPlugin("failing", {
+      buildPlugin("after", {
         async init() {
-          throw new Error("mid-bootstrap failure");
+          initialized.push("after");
         },
         async onShutdown() {
-          // Never called — this plugin never completes init, so it was never
-          // added to the active list that teardown walks.
-          callOrder.push("failing");
+          shutDownDuringBootstrap.push("after");
         },
       }),
     );
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-
-    // Reverse order: survivor-b registered after survivor-a, so it tears
-    // down first; "failing" never entered the active list.
-    expect(callOrder).toEqual(["survivor-b", "survivor-a"]);
+    // WHEN bootstrap runs
+    await bootstrapPlugins();
+
+    // THEN both healthy plugins initialized — the one registered after the
+    // failure is not skipped
+    expect(initialized).toEqual(["before", "after"]);
+    // AND neither healthy plugin was torn down by the failure (their
+    // onShutdown only runs at real shutdown, not during bootstrap)
+    expect(shutDownDuringBootstrap).toEqual([]);
+    // AND the failing plugin is dropped while both survivors remain registered
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).toContain("before");
+    expect(names).toContain("after");
+    expect(names).not.toContain("failing");
+  });
+
+  test("user-plugin init failure leaves the first-party defaults registered", async () => {
+    // GIVEN the first-party defaults are registered ahead of user plugins, as
+    // at daemon startup
+    registerDefaultPlugins();
+    // AND a user plugin registered after them whose init throws
+    registerPlugin(
+      buildPlugin("breaking-user-plugin", {
+        async init() {
+          throw new Error("user plugin boom");
+        },
+      }),
+    );
+
+    // WHEN bootstrap runs
+    await bootstrapPlugins();
+
+    // THEN the failing user plugin is dropped from the registry
+    const names = getRegisteredPlugins().map((p) => p.manifest.name);
+    expect(names).not.toContain("breaking-user-plugin");
+    // AND every first-party default survived, so core turn behavior (memory
+    // retrieval, history repair, title generation) keeps running in degraded
+    // mode instead of being torn down with the failing plugin
+    expect(names).toContain("default-memory-retrieval");
+    expect(names).toContain("default-history-repair");
+    expect(names).toContain("default-title-generate");
   });
 
   test("shutdown order: onShutdown fires in reverse registration order", async () => {
@@ -485,33 +504,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-skill-contribution.test.ts

@@ -202,7 +202,8 @@ describe("plugin skill contributions", () => {
     expect(getPluginContributedSkillSummaries()).toEqual([]);
   });
 
-  test("duplicate skill id across plugins fails bootstrap with the plugin named", async () => {
+  test("duplicate skill id across plugins drops the colliding plugin, keeping the first", async () => {
+    // GIVEN two plugins that both declare the same skill id
     const shared: PluginSkillRegistration = {
       id: "contested-id",
       name: "contested",
@@ -215,22 +216,22 @@ describe("plugin skill contributions", () => {
       description: "Second",
       body: "from second plugin",
     };
-
+    // AND the first registered plugin claims the id; the second collides on it
     registerPlugin(buildSkillPlugin("first-plugin", [shared]));
     registerPlugin(buildSkillPlugin("second-plugin", [duplicate]));
 
-    let caught: unknown;
-    try {
-      await bootstrapPlugins();
-    } catch (err) {
-      caught = err;
-    }
-    expect(caught).toBeInstanceOf(PluginExecutionError);
-    // The error must identify which plugin tripped the collision so
-    // operators can deploy a fix.
-    const msg = (caught as PluginExecutionError).message;
-    expect(msg).toContain("second-plugin");
-    expect(msg).toContain("contested-id");
+    // WHEN bootstrap runs
+    // THEN it does not throw — the collision is contained to the colliding
+    // plugin rather than aborting the whole plugin layer
+    await bootstrapPlugins();
+
+    // AND the first plugin keeps the contested skill, while the second
+    // plugin's colliding contribution is rolled back and dropped
+    expect(
+      getPluginContributedSkillDefinition("contested-id")?.description,
+    ).toBe("First");
+    expect(getPluginSkillRefCount("first-plugin")).toBe(1);
+    expect(getPluginSkillRefCount("second-plugin")).toBe(0);
   });
 
   test("intra-batch duplicate skill id in one plugin is rejected at registration", () => {

package/src/__tests__/plugin-tool-contribution.test.ts

@@ -218,9 +218,7 @@ describe("plugin tool contributions", () => {
   });
 
   test("tools are only registered after init() succeeds", async () => {
-    // A plugin whose init throws must not contribute tools — the bootstrap
-    // aborts with a PluginExecutionError, and nothing from this plugin
-    // should leak into the tool registry.
+    // GIVEN a plugin that declares a tool but throws during init()
     const plugin = buildPlugin("delta-broken", {
       async init() {
         throw new Error("boom");
@@ -229,7 +227,12 @@ describe("plugin tool contributions", () => {
     });
     registerPlugin(plugin);
 
-    await expect(bootstrapPlugins()).rejects.toThrow(/delta-broken/);
+    // WHEN bootstrap runs
+    // THEN it does not throw — the init failure is contained to this plugin
+    await bootstrapPlugins();
+
+    // AND the failing plugin's tool is rolled back, never leaking into the
+    // registry
     expect(getTool("delta-tool")).toBeUndefined();
   });
 });

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

@@ -13,18 +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 CircuitBreakerArgs,
-  type CircuitBreakerResult,
-  type CompactionArgs,
-  type CompactionResult,
-  type Middleware,
-  type OverflowReduceArgs,
-  type OverflowReduceResult,
   type Plugin,
   PluginExecutionError,
   type PluginInitContext,
   type PluginManifest,
-  PluginTimeoutError,
   type TurnContext,
 } from "../plugins/types.js";
 import type { Tool } from "../tools/types.js";
@@ -38,7 +30,6 @@ const sampleTurnContext: TurnContext = {
   requestId: "req-abc",
   conversationId: "conv-xyz",
   turnIndex: 0,
-  pluginName: "sample-plugin",
   trust: sampleTrust,
 };
 
@@ -52,43 +43,6 @@ describe("plugin core types", () => {
       config: { parse: (input: unknown) => input },
     };
 
-    // `overflowReduce` has a concrete arg/result shape (PR 23). Uses a
-    // dedicated passthrough that returns a structurally-correct result so
-    // `satisfies Plugin` keeps verifying the signature.
-    const overflowReducePassthrough: Middleware<
-      OverflowReduceArgs,
-      OverflowReduceResult
-    > = async (args, _next, _ctx) => ({
-      messages: args.messages,
-      runMessages: args.runMessages,
-      injectionMode: "full",
-      reducerState: {
-        appliedTiers: [],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      reducerCompacted: false,
-      attempts: 0,
-    });
-
-    // Slot-specific passthrough for the `compaction` pipeline — PR 25
-    // narrowed its args/result away from the generic `{ input: unknown }`
-    // placeholder, so the generic `passthrough` no longer satisfies its
-    // middleware signature. This dedicated middleware keeps the shape-only
-    // assertion for the slot without forcing every other slot to narrow.
-    const compactionPassthrough: Middleware<
-      CompactionArgs,
-      CompactionResult
-    > = async (args, next, _ctx) => next(args);
-
-    // `circuitBreaker` carries a concrete arg shape (pipeline wrapping
-    // landed ahead of the other slots) so it needs its own passthrough
-    // rather than reusing the generic placeholder.
-    const circuitPassthrough: Middleware<
-      CircuitBreakerArgs,
-      CircuitBreakerResult
-    > = async (args, next, _ctx) => next(args);
-
     const sampleTool: Tool = {
       name: "sample-tool",
       description: "Sample plugin tool",
@@ -132,34 +86,10 @@ describe("plugin core types", () => {
           body: "## Sample\n\nPlugin-provided skill body.",
         },
       ],
-      middleware: {
-        compaction: compactionPassthrough,
-        overflowReduce: overflowReducePassthrough,
-        circuitBreaker: circuitPassthrough,
-      },
     } 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("circuitBreaker", undefined, 1234);
-    expect(err.pluginName).toBeUndefined();
-    expect(err.message).not.toContain("offending plugin");
   });
 
   test("PluginExecutionError carries the plugin name and message", () => {

package/src/__tests__/post-turn-tool-result-truncation.test.ts

@@ -12,6 +12,7 @@ import {
   TARGET_CHARS,
   THRESHOLD_CHARS,
   TOOL_RESULT_DIR,
+  TRUNCATION_EXEMPT_TOOLS,
   TRUNCATION_MARKER,
 } from "../context/post-turn-tool-result-truncation.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -151,6 +152,74 @@ describe("postTurnTruncateToolResults", () => {
     expect(stub).toContain(filePath);
   });
 
+  test("skill_load result above threshold is NOT truncated (durable instructions exempt)", () => {
+    // Regression for JARVIS-1000: a hosted assistant lost its app-builder skill
+    // workflow when the large skill_load result was middle-truncated between the
+    // turn that loaded the skill and the turn that used it, then fell back to a
+    // local-dev (vite/localhost) build path.
+    const toolUseId = "tool_skill_load";
+    const skillBody = "S".repeat(THRESHOLD_CHARS + 5_000);
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use" as const,
+            id: toolUseId,
+            name: "skill_load",
+            input: { skill: "app-builder" },
+          },
+        ],
+      },
+      { role: "user", content: [makeToolResult(skillBody, toolUseId)] },
+    ];
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(0);
+    expect(result).toBe(messages); // same reference — no copy
+    expect(existsSync(join(convDir, TOOL_RESULT_DIR))).toBe(false);
+
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
+    expect(block.content).toBe(skillBody);
+    expect(TRUNCATION_EXEMPT_TOOLS.has("skill_load")).toBe(true);
+  });
+
+  test("non-exempt tool result above threshold is still truncated when paired with a tool_use", () => {
+    // Control for the exemption: same shape as the skill_load case, but a tool
+    // that is NOT exempt must still be truncated.
+    const toolUseId = "tool_bash_1";
+    const longContent = "B".repeat(THRESHOLD_CHARS + 5_000);
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use" as const,
+            id: toolUseId,
+            name: "bash",
+            input: { command: "cat big.log" },
+          },
+        ],
+      },
+      { role: "user", content: [makeToolResult(longContent, toolUseId)] },
+    ];
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(1);
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
+    expect(block.content).toContain(TRUNCATION_MARKER);
+  });
+
   test("file path is deterministic for the same toolUseId", () => {
     const id = "tool_use_deterministic";
     const path1 = getToolResultFilePath("/some/dir", id);