@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

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

@@ -7,7 +7,8 @@
  * - Version-mismatch registration fails with an error that names the plugin
  *   (the registry enforces this at `registerPlugin` time, so bootstrap never
  *   sees the malformed plugin).
- * - Shutdown hook walks plugins in reverse registration order.
+ * - Plugins' `shutdown` hooks fire through the unified `runHook(HOOKS.SHUTDOWN)`
+ *   pipeline; `.disabled` plugins are excluded from that dispatch.
  *
  * `resetPluginRegistryForTests()` isolates registry state between cases.
  */
@@ -18,11 +19,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { clearFeatureFlagOverridesCache } from "../config/assistant-feature-flags.js";
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
-import { runShutdownHooks } from "../daemon/shutdown-registry.js";
-import { RiskLevel } from "../permissions/types.js";
+import { HOOKS } from "../plugin-api/constants.js";
 import { registerDefaultPlugins } from "../plugins/defaults/index.js";
+import { runHook } from "../plugins/pipeline.js";
 import {
   closeRegistration,
   getRegisteredPlugins,
@@ -31,7 +31,6 @@ import {
 } from "../plugins/registry.js";
 import { type InitContext, type Plugin } from "../plugins/types.js";
 import { APP_VERSION } from "../version.js";
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // Redirect plugin storage directory creation into a per-process temp tree so
 // the test doesn't touch the developer's real ~/.vellum.
@@ -54,9 +53,6 @@ function buildPlugin(
     init?: (ctx: InitContext) => Promise<void>;
     onShutdown?: () => Promise<void>;
   } = {},
-  options: {
-    requiresFlag?: string[];
-  } = {},
 ): Plugin {
   const {
     init: legacyInit,
@@ -80,7 +76,6 @@ function buildPlugin(
     manifest: {
       name,
       version: "0.0.1",
-      ...(options.requiresFlag ? { requiresFlag: options.requiresFlag } : {}),
     },
     ...rest,
     ...(mergedHooks ? { hooks: mergedHooks } : {}),
@@ -90,10 +85,6 @@ function buildPlugin(
 describe("plugin bootstrap", () => {
   beforeEach(async () => {
     resetPluginRegistryForTests();
-    // Reset feature-flag cache so tests start from a known state. Individual
-    // tests that exercise `requiresFlag` use `setOverridesForTesting(...)`
-    // to install their own overrides.
-    clearFeatureFlagOverridesCache();
     // Clean storage directory between runs so nothing leaks across cases.
     await rm(TEST_WORKSPACE_DIR, { recursive: true, force: true });
   });
@@ -233,7 +224,7 @@ describe("plugin bootstrap", () => {
     expect(names).toContain("default-title-generate");
   });
 
-  test("shutdown order: onShutdown fires in reverse registration order", async () => {
+  test("shutdown: onShutdown fires through the runHook pipeline in registration order", async () => {
     const callOrder: string[] = [];
     registerPlugin(
       buildPlugin("first-registered", {
@@ -251,12 +242,15 @@ describe("plugin bootstrap", () => {
     );
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
+    // The plugins' `shutdown` hooks fire through the unified pipeline — the same
+    // dispatch path (and registration order) as every other lifecycle hook, so
+    // the first plugin to register runs first.
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: APP_VERSION,
+      reason: "shutdown",
+    });
 
-    // The last plugin to register must shut down first; the first to register
-    // shuts down last. Symmetric tear-down around registration order is the
-    // whole point of the reverse walk.
-    expect(callOrder).toEqual(["second-registered", "first-registered"]);
+    expect(callOrder).toEqual(["first-registered", "second-registered"]);
   });
 
   test("empty registry: bootstrap seeds the first-party defaults without throwing", async () => {
@@ -300,186 +294,15 @@ describe("plugin bootstrap", () => {
     );
   });
 
-  // ── requiresFlag gating (G2.2) ──────────────────────────────────────────
-  //
-  // Plugins that declare `manifest.requiresFlag: [key1, ...]` must only
-  // activate when ALL listed flag keys resolve to `true` at bootstrap.
-  // "Skipping" a plugin means:
-  //   - init() is not invoked,
-  //   - tools/routes/skills are not registered,
-  //   - no shutdown hook entry is installed (nothing to tear down later).
-  // Plugins without `requiresFlag` are unaffected.
-  //
-  // Uses `setOverridesForTesting` to control the resolver deterministically
-  // — no disk writes, no gateway IPC, no reliance on registry defaults.
-
-  test("requiresFlag enabled: plugin inits normally", async () => {
-    setOverridesForTesting({ "plugin-gated-enabled": true });
-
-    let initFired = false;
-    const plugin = buildPlugin(
-      "gated-on",
-      {
-        async init() {
-          initFired = true;
-        },
-      },
-      { requiresFlag: ["plugin-gated-enabled"] },
-    );
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-
-    expect(initFired).toBe(true);
-  });
-
-  test("requiresFlag disabled: init does not fire and no tools/routes are registered", async () => {
-    setOverridesForTesting({ "plugin-gated-disabled": false });
-
-    let initFired = false;
-    // Attach tool/route contributions alongside init. If gating works,
-    // none of them should land in their respective registries.
-    const plugin = buildPlugin(
-      "gated-off",
-      {
-        async init() {
-          initFired = true;
-        },
-        tools: [
-          {
-            name: "gated-off-tool",
-            description: "should not be registered",
-            category: "test",
-            defaultRiskLevel: RiskLevel.Low,
-            executionTarget: "sandbox",
-            input_schema: { type: "object", properties: {}, required: [] },
-            execute: async () => ({ content: "nope", isError: false }),
-          },
-        ],
-        routes: [
-          {
-            // Unique pattern so we don't collide with any other test's route.
-            pattern: /^\/_plugin\/gated-off\/status$/,
-            methods: ["GET"],
-            handler: async () => new Response("ok"),
-          },
-        ],
-      },
-      { requiresFlag: ["plugin-gated-disabled"] },
-    );
-    registerPlugin(plugin);
-
-    // Grab tool / route introspection helpers lazily so the import
-    // side effect happens after `mock.module` has taken effect.
-    const { getTool } = await import("../tools/registry.js");
-    const { matchSkillRoute } =
-      await import("../runtime/skill-route-registry.js");
-
-    await bootstrapPlugins();
-
-    // init must not have fired.
-    expect(initFired).toBe(false);
-    // No tool contributed.
-    expect(getTool("gated-off-tool")).toBeUndefined();
-    // No route wired up — `matchSkillRoute` returns null when nothing matches.
-    expect(matchSkillRoute("/_plugin/gated-off/status", "GET")).toBeNull();
-  });
-
-  test("requiresFlag absent: plugin activates unconditionally", async () => {
-    // Deliberately do not set any overrides — a plugin with no
-    // `requiresFlag` key must not consult the resolver at all.
-    let initFired = false;
-    const plugin = buildPlugin("no-flag", {
-      async init() {
-        initFired = true;
-      },
-    });
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-
-    expect(initFired).toBe(true);
-  });
-
-  test("requiresFlag: one disabled flag out of several skips the plugin", async () => {
-    // When ANY listed flag is disabled, the plugin is skipped wholesale —
-    // this prevents sneaky partial activation on AND semantics.
-    setOverridesForTesting({
-      "plugin-multi-a": true,
-      "plugin-multi-b": false,
-    });
-
-    let initFired = false;
-    const plugin = buildPlugin(
-      "multi-flag",
-      {
-        async init() {
-          initFired = true;
-        },
-      },
-      { requiresFlag: ["plugin-multi-a", "plugin-multi-b"] },
-    );
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-
-    expect(initFired).toBe(false);
-  });
-
-  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-registry",
-      {},
-      { requiresFlag: ["plugin-registry-disabled"] },
-    );
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-
-    // 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 () => {
-    setOverridesForTesting({ "plugin-shutdown-flag": false });
-
-    let shutdownFired = false;
-    const plugin = buildPlugin(
-      "shutdown-skipped",
-      {
-        async init() {},
-        async onShutdown() {
-          shutdownFired = true;
-        },
-      },
-      { requiresFlag: ["plugin-shutdown-flag"] },
-    );
-    registerPlugin(plugin);
-
-    await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
-
-    // The shutdown hook is a single registered callback that walks a
-    // snapshot taken at bootstrap. A skipped plugin should never appear in
-    // that snapshot, so its `onShutdown` must never fire.
-    expect(shutdownFired).toBe(false);
-  });
-
   // ── .disabled sentinel gating ──────────────────────────────────────────
   //
   // A plugin is disabled when a `.disabled` file exists at
   // <workspace>/plugins/<manifest-name>/.disabled. The bootstrap must
-  // skip the plugin's init, tools, routes, and shutdown hook. Unlike the
-  // requiresFlag gate, the plugin is NOT removed from the registry — its
-  // hooks stay registered and are filtered at read time by
-  // `isPluginDisabled` in `getHooksFor`, so `assistant plugins enable`
-  // takes effect on the next turn without a restart.
+  // skip the plugin's init, tools, routes, and shutdown hook. The plugin
+  // is NOT removed from the registry — its hooks stay registered and are
+  // filtered at read time by `isPluginDisabled` in `getHooksFor`, so
+  // `assistant plugins enable` takes effect on the next turn without a
+  // restart.
 
   test(".disabled sentinel: init does not fire and hooks are filtered at read time", async () => {
     let initFired = false;
@@ -549,8 +372,14 @@ describe("plugin bootstrap", () => {
     await writeFile(join(sentinelDir, ".disabled"), "");
 
     await bootstrapPlugins();
-    await runShutdownHooks("test-shutdown");
+    await runHook(HOOKS.SHUTDOWN, {
+      assistantVersion: APP_VERSION,
+      reason: "shutdown",
+    });
 
+    // A `.disabled` plugin keeps its hooks registered but they are filtered out
+    // at read time by `isPluginDisabled` inside `getHooksFor`, so the pipeline
+    // dispatch skips its `onShutdown` too.
     expect(shutdownFired).toBe(false);
 
     await rm(sentinelDir, { recursive: true, force: true });

package/src/__tests__/plugin-disabled-state.test.ts

@@ -261,6 +261,7 @@ describe("per-surface disabled-state filtering", () => {
 
   test("persistence hooks no-op while the memory plugin is disabled", async () => {
     let calls = 0;
+    const bufferLines = 25;
     const guarded = guardPersistenceHooksByDisabledState("default-memory", {
       onMessagePersisted() {
         calls++;
@@ -269,7 +270,13 @@ describe("per-surface disabled-state filtering", () => {
       onConversationWiped() {
         return 0;
       },
+      onConversationDeleted() {},
+      onMessagesDeleted() {},
+      async onAllConversationsCleared() {},
       onWorkerStartup() {},
+      countMemoryBufferLines() {
+        return bufferLines;
+      },
     });
     const event: MessagePersistedEvent = {
       messageId: "msg-1",
@@ -282,21 +289,29 @@ describe("per-surface disabled-state filtering", () => {
     // Enabled: the wrapped handler runs.
     await guarded.onMessagePersisted(event);
     expect(calls).toBe(1);
+    // The gated query returns the real buffer count while enabled.
+    expect(guarded.countMemoryBufferLines()).toBe(25);
 
     // Disable via sentinel — checked at call time, no restart needed.
     await createSentinel("default-memory");
     await guarded.onMessagePersisted(event);
     expect(calls).toBe(1);
+    // Gated: reports an empty buffer while disabled, so consolidation stays inert.
+    expect(guarded.countMemoryBufferLines()).toBe(0);
 
     // Re-enable.
     await removeSentinel("default-memory");
     await guarded.onMessagePersisted(event);
     expect(calls).toBe(2);
+    expect(guarded.countMemoryBufferLines()).toBe(25);
   });
 
   test("cleanup persistence hooks run even while the memory plugin is disabled", async () => {
     let wiped = 0;
     let swept = 0;
+    const deleted: string[][] = [];
+    const convDeleted: string[] = [];
+    let cleared = 0;
     const guarded = guardPersistenceHooksByDisabledState("default-memory", {
       onMessagePersisted() {},
       onConversationForked() {},
@@ -304,9 +319,21 @@ describe("per-surface disabled-state filtering", () => {
         wiped++;
         return 7;
       },
+      onConversationDeleted(id) {
+        convDeleted.push(id);
+      },
+      onMessagesDeleted(ids) {
+        deleted.push(ids);
+      },
+      async onAllConversationsCleared() {
+        cleared++;
+      },
       onWorkerStartup() {
         swept++;
       },
+      countMemoryBufferLines() {
+        return 0;
+      },
     });
 
     await createSentinel("default-memory");
@@ -314,8 +341,14 @@ describe("per-surface disabled-state filtering", () => {
     // Cleanup hooks are NOT gated: they must still run (and return real values)
     // while disabled, or state created while enabled would be orphaned.
     expect(guarded.onConversationWiped("conv-1")).toBe(7);
+    guarded.onConversationDeleted("conv-9");
+    guarded.onMessagesDeleted(["msg-1", "msg-2"]);
+    await guarded.onAllConversationsCleared();
     guarded.onWorkerStartup();
     expect(wiped).toBe(1);
+    expect(convDeleted).toEqual(["conv-9"]);
+    expect(deleted).toEqual([["msg-1", "msg-2"]]);
+    expect(cleared).toBe(1);
     expect(swept).toBe(1);
 
     await removeSentinel("default-memory");

package/src/__tests__/plugin-effective-enabled-set.test.ts

@@ -0,0 +1,227 @@
+/**
+ * Tests for per-chat plugin scope (`enabledPlugins`) filtering at the runtime
+ * injector and lifecycle-hook gather sites.
+ *
+ * A conversation may restrict which plugins' capabilities it uses. That scope
+ * is expressed as an effective-enabled-plugin Set (see
+ * `getEffectiveEnabledPluginSet` in `daemon/conversation-tool-setup.ts`): a
+ * non-null Set is an allowlist, `null` means no restriction. This suite locks
+ * the contract that both gather sites honor it:
+ *  - `getRegisteredInjectors(set)` excludes injectors from plugins outside the
+ *    set, and is unchanged for `null`/omitted.
+ *  - `getHooksFor(name, { conversationId })` resolves the conversation's scope
+ *    and excludes in-process default-plugin hooks outside it; omitting the
+ *    conversationId imposes no restriction.
+ *  - `collectUserHooks(name, dirs, set)` excludes user-land plugin hooks outside
+ *    the set, while standalone workspace hooks (not owned by a plugin) still run.
+ *
+ * The per-chat scope layers on top of (does not replace) the global
+ * `.disabled` sentinel check — a plugin excluded by either is excluded.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// `getHooksFor` resolves the per-chat scope from a conversationId via this
+// module; stub it so the hook tests can drive the effective set directly.
+const resolveScopeMock = mock(
+  (_conversationId: string): Set<string> | null => null,
+);
+mock.module("../daemon/conversation-plugin-scope.js", () => ({
+  resolveConversationPluginScope: (id: string) => resolveScopeMock(id),
+}));
+
+import { collectUserHooks } from "../hooks/hook-loader.js";
+import { getHooksFor } from "../hooks/registry.js";
+import {
+  clearInjectorRegistry,
+  getRegisteredInjectors,
+  registerPluginInjectors,
+} from "../plugins/injector-registry.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { HookFunction, Injector, Plugin } from "../plugins/types.js";
+
+// Point the workspace at an empty temp dir so `getHooksFor` -> `getUserHooksFor`
+// finds no user-land plugins; the in-process hook tests then observe only the
+// hooks registered through `registerPlugin`.
+const TEST_WORKSPACE_DIR = join(
+  tmpdir(),
+  `vellum-plugin-effective-set-${process.pid}-${Date.now()}`,
+);
+process.env.VELLUM_WORKSPACE_DIR = TEST_WORKSPACE_DIR;
+
+function injector(name: string, order: number): Injector {
+  return { name, order, produce: () => Promise.resolve(null) };
+}
+
+function buildPlugin(
+  name: string,
+  hooks: Record<string, HookFunction>,
+): Plugin {
+  return { manifest: { name, version: "1.0.0" }, hooks };
+}
+
+describe("getRegisteredInjectors per-chat plugin scope", () => {
+  beforeEach(() => clearInjectorRegistry());
+  afterEach(() => clearInjectorRegistry());
+
+  test("null set runs every globally-enabled plugin's injectors (unchanged)", () => {
+    registerPluginInjectors("plugin-a", [injector("inj-a", 1)]);
+    registerPluginInjectors("plugin-b", [injector("inj-b", 2)]);
+
+    const namesNull = getRegisteredInjectors(null).map((i) => i.name);
+    const namesOmitted = getRegisteredInjectors().map((i) => i.name);
+
+    expect(namesNull).toEqual(["inj-a", "inj-b"]);
+    expect(namesOmitted).toEqual(["inj-a", "inj-b"]);
+  });
+
+  test("a set excluding plugin b drops b's injectors and keeps a's", () => {
+    registerPluginInjectors("plugin-a", [injector("inj-a", 1)]);
+    registerPluginInjectors("plugin-b", [injector("inj-b", 2)]);
+
+    const names = getRegisteredInjectors(new Set(["plugin-a"])).map(
+      (i) => i.name,
+    );
+
+    expect(names).toEqual(["inj-a"]);
+  });
+
+  test("an empty set excludes every plugin's injectors", () => {
+    registerPluginInjectors("plugin-a", [injector("inj-a", 1)]);
+    registerPluginInjectors("plugin-b", [injector("inj-b", 2)]);
+
+    expect(getRegisteredInjectors(new Set<string>())).toEqual([]);
+  });
+});
+
+describe("getHooksFor per-chat plugin scope (in-process default hooks)", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    resolveScopeMock.mockReset();
+    resolveScopeMock.mockImplementation(() => null);
+  });
+  afterEach(() => resetPluginRegistryForTests());
+
+  test("no conversationId (or an unrestricted one) runs both plugins' hooks", async () => {
+    registerPlugin(
+      buildPlugin("default-a", {
+        "user-prompt-submit": () => Promise.resolve(),
+      }),
+    );
+    registerPlugin(
+      buildPlugin("default-b", {
+        "user-prompt-submit": () => Promise.resolve(),
+      }),
+    );
+
+    // No conversationId → the resolver is never consulted.
+    expect(await getHooksFor("user-prompt-submit")).toHaveLength(2);
+    expect(resolveScopeMock).not.toHaveBeenCalled();
+    // A conversationId whose scope resolves to null (no restriction).
+    expect(
+      await getHooksFor("user-prompt-submit", { conversationId: "c1" }),
+    ).toHaveLength(2);
+  });
+
+  test("a scope excluding plugin b drops b's hooks and keeps a's", async () => {
+    let aRan = 0;
+    let bRan = 0;
+    registerPlugin(
+      buildPlugin("default-a", {
+        "user-prompt-submit": () => {
+          aRan++;
+          return Promise.resolve();
+        },
+      }),
+    );
+    registerPlugin(
+      buildPlugin("default-b", {
+        "user-prompt-submit": () => {
+          bRan++;
+          return Promise.resolve();
+        },
+      }),
+    );
+    resolveScopeMock.mockImplementation(() => new Set(["default-a"]));
+
+    const hooks = await getHooksFor("user-prompt-submit", {
+      conversationId: "c1",
+    });
+    expect(hooks).toHaveLength(1);
+    expect(resolveScopeMock).toHaveBeenCalledWith("c1");
+
+    // The surviving hook is a's, not b's.
+    await hooks[0]!({});
+    expect(aRan).toBe(1);
+    expect(bRan).toBe(0);
+  });
+
+  test("an empty scope excludes every plugin's hooks", async () => {
+    registerPlugin(
+      buildPlugin("default-a", {
+        "user-prompt-submit": () => Promise.resolve(),
+      }),
+    );
+    resolveScopeMock.mockImplementation(() => new Set<string>());
+    expect(
+      await getHooksFor("user-prompt-submit", { conversationId: "c1" }),
+    ).toHaveLength(0);
+  });
+});
+
+describe("collectUserHooks per-chat plugin scope (user-land hooks)", () => {
+  let root: string;
+  let counter = 0;
+
+  beforeEach(() => {
+    root = join(
+      tmpdir(),
+      `vellum-userhooks-${process.pid}-${Date.now()}-${counter++}`,
+    );
+    mkdirSync(root, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  function pluginDirWithHook(name: string): string {
+    const dir = join(root, name);
+    const hooksDir = join(dir, "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(
+      join(hooksDir, "user-prompt-submit.ts"),
+      "export default () => ({});\n",
+    );
+    return dir;
+  }
+
+  test("null set runs both user plugins' hooks (unchanged)", async () => {
+    const dirs: Array<readonly [string, string]> = [
+      [pluginDirWithHook("uplug-a"), "uplug-a"],
+      [pluginDirWithHook("uplug-b"), "uplug-b"],
+    ];
+
+    expect(await collectUserHooks("user-prompt-submit", dirs)).toHaveLength(2);
+    expect(
+      await collectUserHooks("user-prompt-submit", dirs, null),
+    ).toHaveLength(2);
+  });
+
+  test("a set excluding plugin b drops b's user-land hook", async () => {
+    const dirs: Array<readonly [string, string]> = [
+      [pluginDirWithHook("uplug-a"), "uplug-a"],
+      [pluginDirWithHook("uplug-b"), "uplug-b"],
+    ];
+
+    expect(
+      await collectUserHooks("user-prompt-submit", dirs, new Set(["uplug-a"])),
+    ).toHaveLength(1);
+  });
+});