@vellumai/assistant 0.10.3 → 0.10.4-staging.1

package/src/__tests__/persona-resolver.test.ts

@@ -31,16 +31,33 @@ import {
 
 // ── Mock state ────────────────────────────────────────────────────
 
+interface GuardianDeliveryStub {
+  channelType: string;
+  address: string;
+  status: string;
+}
+
 let mockWorkspaceDir: string = "";
-let mockVellumGuardian: {
-  contact: { userFile: string | null };
-  channel: Record<string, unknown>;
-} | null = null;
-let mockAnyGuardian: {
-  contact: { userFile: string | null };
-  channels: Record<string, unknown>[];
-} | null = null;
+// Gateway guardian delivery cache, keyed by the same source the production
+// peek reads; the guardian's userFile (local INFO) is joined separately via
+// findContactByAddress on the delivery's address.
+let mockGuardianDeliveries: GuardianDeliveryStub[] = [];
 let mockContactsByAddress: Record<string, { userFile: string | null }> = {};
+// Simulates a cold sync cache: the sync `peek` returns nothing until the async
+// `getGuardianDelivery` warm runs and populates `mockGuardianDeliveries`. The
+// pending list is what the warm reveals.
+let pendingWarmDeliveries: GuardianDeliveryStub[] | null = null;
+
+/**
+ * Seed a vellum guardian: a gateway delivery for the vellum channel plus the
+ * local contact (by address) carrying its userFile.
+ */
+function seedVellumGuardian(userFile: string | null): void {
+  mockGuardianDeliveries = [
+    { channelType: "vellum", address: "vellum:self", status: "active" },
+  ];
+  mockContactsByAddress["vellum:vellum:self"] = { userFile };
+}
 
 // ── Mock modules (must precede imports from the module under test) ──
 
@@ -51,13 +68,32 @@ mock.module("../util/platform.js", () => ({
 mock.module("../contacts/contact-store.js", () => ({
   findContactByAddress: (channelType: string, address: string) =>
     mockContactsByAddress[`${channelType}:${address}`] ?? null,
-  findGuardianForChannel: (channelType: string) =>
-    channelType === "vellum" ? mockVellumGuardian : null,
-  listGuardianChannels: () => mockAnyGuardian,
+}));
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  peekCachedGuardianDelivery: (input?: { channelTypes?: string[] }) => {
+    if (!input?.channelTypes) return mockGuardianDeliveries;
+    return mockGuardianDeliveries.filter((g) =>
+      input.channelTypes!.includes(g.channelType),
+    );
+  },
+  // Warming the cache: reveals the pending guardian to the sync peek above,
+  // mirroring how the production single-flight read populates the cache key.
+  getGuardianDelivery: async (_input?: { channelTypes?: string[] }) => {
+    if (pendingWarmDeliveries) {
+      mockGuardianDeliveries = pendingWarmDeliveries;
+      pendingWarmDeliveries = null;
+    }
+    return mockGuardianDeliveries;
+  },
+  guardianForChannel: (list: GuardianDeliveryStub[], channelType: string) =>
+    list.find((g) => g.channelType === channelType && g.status === "active"),
+  anyGuardian: (list: GuardianDeliveryStub[]) => list[0],
 }));
 
 // Import AFTER mocks so the module under test binds to the stubbed
 // implementations.
+import { getGuardianDelivery } from "../contacts/guardian-delivery-reader.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import {
   ensureGuardianPersonaFile,
@@ -83,9 +119,9 @@ afterAll(() => {
 beforeEach(() => {
   // Fresh workspace per test, so filesystem state doesn't leak.
   mockWorkspaceDir = mkdtempSync(join(testRoot, "ws-"));
-  mockVellumGuardian = null;
-  mockAnyGuardian = null;
+  mockGuardianDeliveries = [];
   mockContactsByAddress = {};
+  pendingWarmDeliveries = null;
 });
 
 afterEach(() => {
@@ -96,21 +132,35 @@ afterEach(() => {
 
 describe("resolveGuardianPersonaPath", () => {
   test("returns null when no guardian exists", () => {
-    mockVellumGuardian = null;
-    mockAnyGuardian = null;
 
     expect(resolveGuardianPersonaPath()).toBeNull();
   });
 
   test("returns absolute path when guardian has userFile set", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
 
     const result = resolveGuardianPersonaPath();
     expect(result).toBe(join(mockWorkspaceDir, "users", "alice.md"));
   });
+
+  test("falls back to default (null path) on a cold cache, but resolves the guardian after a warm", async () => {
+    // Cold start: the guardian binding exists upstream but the sync cache is
+    // empty, so a bare sync resolution misses it and falls back to default.
+    pendingWarmDeliveries = [
+      { channelType: "vellum", address: "vellum:self", status: "active" },
+    ];
+    mockContactsByAddress["vellum:vellum:self"] = { userFile: "alice.md" };
+
+    expect(resolveGuardianPersonaPath()).toBeNull();
+
+    // Async callers warm the vellum guardian-delivery cache before the sync
+    // resolution; afterwards the guardian slug resolves instead of default.md.
+    await getGuardianDelivery({ channelTypes: ["vellum"] });
+
+    expect(resolveGuardianPersonaPath()).toBe(
+      join(mockWorkspaceDir, "users", "alice.md"),
+    );
+  });
 });
 
 // ── ensureGuardianPersonaFile ──────────────────────────────────────
@@ -156,17 +206,12 @@ describe("ensureGuardianPersonaFile", () => {
 
 describe("resolveGuardianPersonaStrict", () => {
   test("returns null when no guardian contact exists", () => {
-    mockVellumGuardian = null;
-    mockAnyGuardian = null;
 
     expect(resolveGuardianPersonaStrict()).toBeNull();
   });
 
   test("returns null when the guardian's own file is missing, even if default.md exists", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
 
     // default.md is populated but alice.md is not on disk.
     const usersDir = join(mockWorkspaceDir, "users");
@@ -185,10 +230,7 @@ describe("resolveGuardianPersonaStrict", () => {
   });
 
   test("returns guardian file content when present", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
 
     const usersDir = join(mockWorkspaceDir, "users");
     mkdirSync(usersDir, { recursive: true });
@@ -260,10 +302,7 @@ describe("isGuardianPersonaCustomized", () => {
 
 describe("resolveUserSlug (guardian trust, no requester identity)", () => {
   test("guardian trust context without requesterExternalUserId resolves the guardian user file", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
 
     const trustContext = {
       sourceChannel: "vellum",
@@ -274,10 +313,7 @@ describe("resolveUserSlug (guardian trust, no requester identity)", () => {
   });
 
   test("non-guardian trust context without requesterExternalUserId does not borrow the guardian persona", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
 
     const trustContext = {
       sourceChannel: "vellum",
@@ -291,10 +327,7 @@ describe("resolveUserSlug (guardian trust, no requester identity)", () => {
     // The verdict-bound guardian is looked up by its address, not by the
     // most-recently-verified channel guardian, so a different channel guardian
     // does not shadow the verdict's binding.
-    mockVellumGuardian = {
-      contact: { userFile: "wrong-guardian.md" },
-      channel: {},
-    };
+    seedVellumGuardian("wrong-guardian.md");
     mockContactsByAddress["telegram:guardian-tg"] = {
       userFile: "alice.md",
     };
@@ -309,10 +342,7 @@ describe("resolveUserSlug (guardian trust, no requester identity)", () => {
   });
 
   test("falls back to the channel guardian when the verdict carries no guardian identity", () => {
-    mockVellumGuardian = {
-      contact: { userFile: "alice.md" },
-      channel: {},
-    };
+    seedVellumGuardian("alice.md");
 
     const trustContext = {
       sourceChannel: "vellum",

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

@@ -475,11 +475,13 @@ describe("plugin bootstrap", () => {
   //
   // A plugin is disabled when a `.disabled` file exists at
   // <workspace>/plugins/<manifest-name>/.disabled. The bootstrap must
-  // skip the plugin entirely — no init, no tools, no routes, no shutdown
-  // hook — and remove it from the registry, mirroring the requiresFlag
-  // gate.
+  // 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.
 
-  test(".disabled sentinel: init does not fire and plugin is unregistered", async () => {
+  test(".disabled sentinel: init does not fire and hooks are filtered at read time", async () => {
     let initFired = false;
     const plugin = buildPlugin("sentinel-off", {
       async init() {
@@ -497,8 +499,14 @@ describe("plugin bootstrap", () => {
     await bootstrapPlugins();
 
     expect(initFired).toBe(false);
+    // The plugin stays in the registry (not unregistered) so its hooks can
+    // be re-enabled at runtime by removing the sentinel.
     const names = getRegisteredPlugins().map((p) => p.manifest.name);
-    expect(names).not.toContain("sentinel-off");
+    expect(names).toContain("sentinel-off");
+    // But its hooks are filtered out at read time by `isPluginDisabled`.
+    const { getHooksFor } = await import("../plugins/registry.js");
+    const hooks = await getHooksFor("init");
+    expect(hooks).toHaveLength(0);
 
     await rm(sentinelDir, { recursive: true, force: true });
   });

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

@@ -0,0 +1,190 @@
+/**
+ * Tests for per-surface plugin disabled-state filtering.
+ *
+ * Verifies that `assistant plugins disable default-*` takes effect on the
+ * next turn without a daemon restart. The `.disabled` sentinel is checked at
+ * read time by each surface (`getHooksFor` for hooks,
+ * `getPluginToolDefinitions` for tools) rather than at boot, so toggling the
+ * sentinel file at runtime is immediately reflected.
+ */
+
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { RiskLevel } from "../permissions/types.js";
+import {
+  getHooksFor,
+  registerPlugin,
+  resetPluginRegistryForTests,
+  unregisterPlugin,
+} from "../plugins/registry.js";
+import { type HookFunction, type Plugin } from "../plugins/types.js";
+import {
+  getPluginToolDefinitions,
+  registerPluginTools,
+} from "../tools/registry.js";
+import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
+
+const TEST_WORKSPACE_DIR = join(
+  tmpdir(),
+  `vellum-plugin-disabled-state-test-${process.pid}-${Date.now()}`,
+);
+process.env.VELLUM_WORKSPACE_DIR = TEST_WORKSPACE_DIR;
+
+async function createSentinel(name: string): Promise<void> {
+  const dir = join(TEST_WORKSPACE_DIR, "plugins", name);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, ".disabled"), "");
+}
+
+async function removeSentinel(name: string): Promise<void> {
+  const dir = join(TEST_WORKSPACE_DIR, "plugins", name);
+  await rm(dir, { recursive: true, force: true });
+}
+
+function buildPlugin(
+  name: string,
+  hooks: Record<string, HookFunction> = {},
+): Plugin {
+  return {
+    manifest: { name, version: "1.0.0" },
+    hooks,
+  };
+}
+
+function makeFakeTool(name: string): Tool {
+  return {
+    name,
+    description: `Fake ${name}`,
+    defaultRiskLevel: RiskLevel.Low,
+    executionTarget: "sandbox",
+    input_schema: { type: "object", properties: {}, required: [] },
+    category: "plugin",
+    async execute(
+      _input: Record<string, unknown>,
+      _context: ToolContext,
+    ): Promise<ToolExecutionResult> {
+      return { content: "ok", isError: false };
+    },
+  };
+}
+
+beforeEach(() => {
+  resetPluginRegistryForTests();
+});
+
+afterEach(async () => {
+  // Clean up any sentinel files created during the test.
+  const pluginsDir = join(TEST_WORKSPACE_DIR, "plugins");
+  if (existsSync(pluginsDir)) {
+    await rm(pluginsDir, { recursive: true, force: true });
+  }
+});
+
+describe("per-surface disabled-state filtering", () => {
+  test("getHooksFor filters out hooks from a disabled plugin", async () => {
+    const plugin = buildPlugin("default-test-hook", {
+      "user-prompt-submit": () => Promise.resolve(),
+    });
+    registerPlugin(plugin);
+
+    // Before disabling: hook is included.
+    const hooksBefore = await getHooksFor("user-prompt-submit");
+    expect(hooksBefore).toHaveLength(1);
+
+    // Disable via sentinel.
+    await createSentinel("default-test-hook");
+
+    // After disabling: hook is filtered out at read time.
+    const hooksAfter = await getHooksFor("user-prompt-submit");
+    expect(hooksAfter).toHaveLength(0);
+
+    // Clean up.
+    await removeSentinel("default-test-hook");
+  });
+
+  test("getHooksFor re-includes hooks when a disabled plugin is re-enabled", async () => {
+    const plugin = buildPlugin("default-test-reenable", {
+      "user-prompt-submit": () => Promise.resolve(),
+    });
+    registerPlugin(plugin);
+
+    // Disable.
+    await createSentinel("default-test-reenable");
+    let hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(0);
+
+    // Re-enable by removing the sentinel.
+    await removeSentinel("default-test-reenable");
+    hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(1);
+  });
+
+  test("getPluginToolDefinitions filters out tools from a disabled plugin", async () => {
+    const plugin: Plugin = {
+      manifest: { name: "default-test-tools", version: "1.0.0" },
+      tools: [makeFakeTool("test_tool")],
+    };
+    registerPlugin(plugin);
+    registerPluginTools("default-test-tools", plugin.tools!);
+
+    // Before disabling: tool is visible.
+    let defs = getPluginToolDefinitions();
+    expect(defs.some((d) => d.name === "test_tool")).toBe(true);
+
+    // Disable via sentinel.
+    await createSentinel("default-test-tools");
+
+    // After disabling: tool is filtered out.
+    defs = getPluginToolDefinitions();
+    expect(defs.some((d) => d.name === "test_tool")).toBe(false);
+
+    // Re-enable.
+    await removeSentinel("default-test-tools");
+    defs = getPluginToolDefinitions();
+    expect(defs.some((d) => d.name === "test_tool")).toBe(true);
+  });
+
+  test("disabling one plugin does not affect others", async () => {
+    const pluginA = buildPlugin("default-test-alpha", {
+      "user-prompt-submit": () => Promise.resolve(),
+    });
+    const pluginB = buildPlugin("default-test-beta", {
+      "user-prompt-submit": () => Promise.resolve(),
+    });
+    registerPlugin(pluginA);
+    registerPlugin(pluginB);
+
+    // Both visible.
+    let hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(2);
+
+    // Disable only alpha.
+    await createSentinel("default-test-alpha");
+    hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(1);
+
+    // Re-enable alpha.
+    await removeSentinel("default-test-alpha");
+    hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(2);
+  });
+
+  test("unregisterPlugin removes hooks from the hook registry", async () => {
+    const plugin = buildPlugin("default-test-unreg", {
+      "user-prompt-submit": () => Promise.resolve(),
+    });
+    registerPlugin(plugin);
+
+    let hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(1);
+
+    unregisterPlugin("default-test-unreg");
+
+    hooks = await getHooksFor("user-prompt-submit");
+    expect(hooks).toHaveLength(0);
+  });
+});

package/src/__tests__/provider-usage-tracking.test.ts

@@ -234,7 +234,7 @@ describe("native web-search capability survives the wrapper chain", () => {
     // UsageTracking → leaf. The advisor consult reads the flag off the top.
     const wrapped = new CallSiteConfiguredProvider(
       new UsageTrackingProvider(leaf(true)),
-      "advisor",
+      "subagentSpawn",
     );
     expect(wrapped.supportsNativeWebSearch).toBe(true);
   });

package/src/__tests__/reaction-intercept-cold-cache-warm.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Cold-cache guardian-reaction regression.
+ *
+ * The sync trust resolver reads the IO-free guardian-delivery cache snapshot
+ * (`peekCachedGuardianDelivery`). On a cold process only `vellum` is warmed at
+ * daemon startup, so for `slack` the snapshot is empty until some read warms
+ * that exact channel key. `handleSlackReactionIntercept` therefore awaits
+ * `getGuardianDelivery({ channelTypes: ["slack"] })` BEFORE the sync resolve so
+ * a guardian's approval reaction classifies as `guardian` rather than dropping
+ * as `unknown`.
+ *
+ * This test drives the REAL guardian-delivery reader cache (mocking only the
+ * gateway `ipcCall`) so the cold→warm transition is exercised end to end.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const GUARDIAN_USER_ID = "U_GUARDIAN_COLD";
+const SLACK_CHANNEL_ID = "C0COLD";
+
+// Gateway IPC stub: returns the slack guardian delivery. The real reader caches
+// the result under the `slack` key, so a subsequent sync `peek` finds it.
+let ipcCalls: Array<{ route: string; input: unknown }> = [];
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async (route: string, input: unknown) => {
+    ipcCalls.push({ route, input });
+    return {
+      guardians: [
+        {
+          channelType: "slack",
+          contactId: "guardian-contact",
+          principalId: GUARDIAN_USER_ID,
+          address: GUARDIAN_USER_ID,
+          externalChatId: SLACK_CHANNEL_ID,
+          status: "active",
+        },
+      ],
+    };
+  },
+}));
+
+// Contact lookup is irrelevant to guardian classification (address match on the
+// cached delivery decides it); return null so member lookup is a no-op.
+mock.module("../contacts/contact-store.js", () => ({
+  findContactByAddress: () => null,
+}));
+
+// Stub downstream side effects so the test isolates trust classification.
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "msg-1" }),
+}));
+mock.module("../memory/delivery-crud.js", () => ({
+  recordInbound: () => ({
+    eventId: "evt-1",
+    conversationId: "conv-1",
+    accepted: true,
+    duplicate: false,
+  }),
+  clearPayload: () => {},
+  linkMessage: () => {},
+}));
+mock.module("../memory/delivery-status.js", () => ({
+  markProcessed: () => {},
+}));
+mock.module("../memory/external-conversation-store.js", () => ({
+  upsertBinding: () => {},
+}));
+mock.module("../daemon/disk-pressure-guard.js", () => ({
+  getDiskPressureStatus: () => ({ level: "ok" }),
+}));
+mock.module("../daemon/disk-pressure-policy.js", () => ({
+  classifyDiskPressureTurnPolicy: () => ({ action: "allow" }),
+}));
+
+// Capture the trustClass the guardian decision pipeline receives — this is the
+// classification produced by the sync resolve after the upstream warm.
+let receivedTrustClass: string | undefined;
+mock.module("../runtime/routes/inbound-stages/guardian-reply-intercept.js", () => ({
+  handleGuardianReplyIntercept: async (params: { trustClass: string }) => {
+    receivedTrustClass = params.trustClass;
+    return { response: { accepted: true, canonicalRouter: "applied" } };
+  },
+}));
+
+import {
+  __resetGuardianDeliveryCacheForTest,
+  peekCachedGuardianDelivery,
+} from "../contacts/guardian-delivery-reader.js";
+import { handleSlackReactionIntercept } from "../runtime/routes/inbound-stages/reaction-intercept.js";
+
+function buildParams() {
+  return {
+    callbackData: "reaction:white_check_mark",
+    sourceChannel: "slack" as const,
+    sourceInterface: "slack" as const,
+    conversationExternalId: SLACK_CHANNEL_ID,
+    externalMessageId: `${SLACK_CHANNEL_ID}:1700000000.1:cold`,
+    canonicalAssistantId: "assistant-1",
+    rawSenderId: GUARDIAN_USER_ID,
+    canonicalSenderId: GUARDIAN_USER_ID,
+    actorDisplayName: "Guardian",
+    actorUsername: undefined,
+    replyCallbackUrl: "http://localhost:7830/deliver/slack",
+    sourceMetadata: { messageId: "1700000000.1", chatType: "channel" } as never,
+    slackChannelName: "general",
+    approvalConversationGenerator: undefined,
+  };
+}
+
+describe("reaction intercept warms the channel guardian cache before sync trust", () => {
+  beforeEach(() => {
+    __resetGuardianDeliveryCacheForTest();
+    ipcCalls = [];
+    receivedTrustClass = undefined;
+  });
+
+  test("cold slack cache: guardian reaction classifies as guardian after upstream warm", async () => {
+    // Precondition: cold cache for slack — the sync peek would miss.
+    expect(peekCachedGuardianDelivery({ channelTypes: ["slack"] })).toBeUndefined();
+
+    await handleSlackReactionIntercept(buildParams());
+
+    // The intercept warmed the slack-specific key via the async reader.
+    expect(
+      ipcCalls.some(
+        (c) =>
+          c.route === "resolve_guardian_delivery" &&
+          JSON.stringify(c.input) === JSON.stringify({ channelTypes: ["slack"] }),
+      ),
+    ).toBe(true);
+
+    // The sync resolve, reading the now-warm snapshot, classified the reactor as
+    // the guardian — not dropped as `unknown`.
+    expect(receivedTrustClass).toBe("guardian");
+  });
+});