@vellumai/assistant 0.12.2-staging.4 → 0.12.2-staging.6

package/src/__tests__/scaffold-managed-skill-tool.test.ts

@@ -171,6 +171,94 @@ describe("scaffold_managed_skill tool", () => {
     });
   });
 
+  test("an overwrite through the tool keeps frontmatter it does not restate", async () => {
+    await executeScaffoldManagedSkill(
+      {
+        skill_id: "edited",
+        name: "Edited",
+        description: "V1",
+        body_markdown: "Old body.",
+        activation_hints: HINTS,
+        emoji: "📊",
+        category: "productivity",
+        includes: ["csv-basics"],
+        avoid_when: ["the report is monthly"],
+      },
+      makeContext(),
+    );
+
+    // The usual "change step 3" edit: body and hints, nothing else restated.
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "edited",
+        name: "Edited",
+        description: "V2",
+        body_markdown: "New body.",
+        activation_hints: HINTS,
+        overwrite: true,
+      },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+
+    const skill = loadSkillCatalog().find((s) => s.id === "edited")!;
+    expect(skill.emoji).toBe("📊");
+    expect(skill.category).toBe("productivity");
+    expect(skill.includes).toEqual(["csv-basics"]);
+    expect(skill.avoidWhen).toEqual(["the report is monthly"]);
+    expect(skill.description).toBe("V2");
+  });
+
+  test("an overwrite through the tool clears a field passed empty, and hints stay required", async () => {
+    await executeScaffoldManagedSkill(
+      {
+        skill_id: "cleared",
+        name: "Cleared",
+        description: "V1",
+        body_markdown: "Body.",
+        activation_hints: HINTS,
+        category: "productivity",
+        avoid_when: ["the report is monthly"],
+      },
+      makeContext(),
+    );
+
+    const noHints = await executeScaffoldManagedSkill(
+      {
+        skill_id: "cleared",
+        name: "Cleared",
+        description: "V2",
+        body_markdown: "Body.",
+        activation_hints: [],
+        overwrite: true,
+      },
+      makeContext(),
+    );
+    // An explicit empty list clears other fields, but hints must track the
+    // body, so an overwrite still has to state them.
+    expect(noHints.isError).toBe(true);
+    expect(noHints.content).toContain("activation_hints is required");
+
+    const result = await executeScaffoldManagedSkill(
+      {
+        skill_id: "cleared",
+        name: "Cleared",
+        description: "V2",
+        body_markdown: "Body.",
+        activation_hints: HINTS,
+        overwrite: true,
+        category: "  ",
+        avoid_when: [],
+      },
+      makeContext(),
+    );
+    expect(result.isError).toBe(false);
+
+    const skill = loadSkillCatalog().find((s) => s.id === "cleared")!;
+    expect(skill.category).toBeUndefined();
+    expect(skill.avoidWhen).toBeUndefined();
+  });
+
   test("the registered tool's schema rejects an omitted activation_hints before the executor runs", () => {
     // A call through the registered tool is validated against TOOLS.json
     // first (skill-tool-factory), so the requirement has to live in the

package/src/calls/__tests__/voice-control-protocol.test.ts

@@ -9,6 +9,7 @@ import {
   parseTerminalSessionControl,
   type SessionControlRequest,
   stripInternalSpeechMarkers,
+  TASK_STOP_MARKER,
   terminalControlMarkerLength,
 } from "../voice-control-protocol.js";
 
@@ -52,13 +53,26 @@ describe("minimize-room marker", () => {
 
 describe("isIncompleteControlMarkerTail", () => {
   test("strict prefixes of any marker are incomplete", () => {
-    for (const tail of ["[", "[-", "[-1", "[END_CAL", "[ASK_GUARDIAN_APPRO"]) {
+    for (const tail of [
+      "[",
+      "[-",
+      "[-1",
+      "[END_CAL",
+      "[TASK:ST",
+      "[ASK_GUARDIAN_APPRO",
+    ]) {
       expect(isIncompleteControlMarkerTail(tail)).toBe(true);
     }
   });
 
   test("complete literal markers are not held", () => {
-    for (const tail of ["[-1]", "[END_CALL]", "[0] answer", "[-1] look here"]) {
+    for (const tail of [
+      "[-1]",
+      "[END_CALL]",
+      TASK_STOP_MARKER,
+      "[0] answer",
+      "[-1] look here",
+    ]) {
       expect(isIncompleteControlMarkerTail(tail)).toBe(false);
     }
   });
@@ -148,6 +162,12 @@ describe("session control markers", () => {
     );
   });
 
+  test("strips the task-stop marker so it is never spoken", () => {
+    expect(stripInternalSpeechMarkers(`Okay. ${TASK_STOP_MARKER}`).trim()).toBe(
+      "Okay.",
+    );
+  });
+
   test("holds a streaming timed mute until its bracket arrives", () => {
     expect(isIncompleteControlMarkerTail("[MU")).toBe(true);
     expect(isIncompleteControlMarkerTail("[MUTE:3")).toBe(true);
@@ -162,6 +182,7 @@ describe("session control markers", () => {
 
   test.each([
     ["Okay, talk soon. [END_CALL]", { action: "end" }],
+    ["Okay, stopping. [TASK:STOP]", { action: "task_stop" }],
     ["Muted. [MUTE]", { action: "mute" }],
     ["Taking a look. [LOOK:SCREEN]", { action: "look_screen" }],
     ["Show me. [LOOK:CAMERA]", { action: "look_camera" }],
@@ -200,6 +221,7 @@ describe("session control markers", () => {
   test("measures the terminal marker the transcript pass strips", () => {
     expect(terminalControlMarkerLength("Done [-1]")).toBe(4);
     expect(terminalControlMarkerLength("Bye [END_CALL] ")).toBe(10);
+    expect(terminalControlMarkerLength("Stopping [TASK:STOP]")).toBe(11);
     expect(terminalControlMarkerLength("Muted [MUTE:30]")).toBe(9);
     expect(terminalControlMarkerLength("Okay [UPDATES:FEWER]")).toBe(15);
     expect(terminalControlMarkerLength("The array [-1] sorts")).toBe(0);

package/src/calls/__tests__/voice-session-bridge.test.ts

@@ -842,6 +842,17 @@ describe("startVoiceTurn triage-and-escalate control prompt", () => {
     expect(installed()).toContain(escalatedContinuationRule());
   });
 
+  test("a direct escalated turn keeps the caller-supplied resume prompt verbatim", async () => {
+    const installed = captureInstalledPrompt();
+    await startVoiceTurn({
+      ...makeTurnOptions(),
+      voiceControlPrompt: LIVE_VOICE_PROMPT,
+      routingLeg: "escalated",
+      directEscalated: true,
+    });
+    expect(installed()).toBe(LIVE_VOICE_PROMPT);
+  });
+
   test("the auto-built phone prompt carries the front-door rule anchored to the caller's words", async () => {
     const installed = captureInstalledPrompt();
     await startVoiceTurn({
@@ -1966,7 +1977,7 @@ describe("startVoiceTurn tool-event forwarding", () => {
     fakeConversation = fake.conversation;
   }
 
-  test("tool_use_start delivers the tool name, toolUseId, and input", async () => {
+  test("tool_use_start delivers the tool name, input, and active allowlist", async () => {
     makeEventEmittingConversation([
       {
         type: "tool_use_start",
@@ -1975,6 +1986,11 @@ describe("startVoiceTurn tool-event forwarding", () => {
         toolUseId: "toolu-1",
       },
     ]);
+    (
+      fakeConversation as typeof fakeConversation & {
+        allowedToolNames?: Set<string>;
+      }
+    ).allowedToolNames = new Set(["web_search"]);
 
     const starts: Array<{ toolName: string; detail?: unknown }> = [];
     await startVoiceTurn({
@@ -1988,7 +2004,11 @@ describe("startVoiceTurn tool-event forwarding", () => {
     expect(starts).toEqual([
       {
         toolName: "web_search",
-        detail: { toolUseId: "toolu-1", input: { query: "weather" } },
+        detail: {
+          toolUseId: "toolu-1",
+          input: { query: "weather" },
+          allowedToolNames: new Set(["web_search"]),
+        },
       },
     ]);
   });

package/src/calls/voice-control-protocol.ts

@@ -13,6 +13,7 @@ export const CALL_OPENING_MARKER = "[CALL_OPENING]";
 export const CALL_OPENING_ACK_MARKER = "[CALL_OPENING_ACK]";
 export const CALL_VERIFICATION_COMPLETE_MARKER = "[CALL_VERIFICATION_COMPLETE]";
 export const END_CALL_MARKER = "[END_CALL]";
+export const TASK_STOP_MARKER = "[TASK:STOP]";
 
 /**
  * Verdict tokens for the fast "front-door" model (triage-and-escalate voice
@@ -89,6 +90,7 @@ const USER_INSTRUCTION_MARKER_REGEX = /\[USER_INSTRUCTION:\s*.+?\]/g;
 const CALL_OPENING_MARKER_REGEX = /\[CALL_OPENING\]/g;
 const CALL_OPENING_ACK_MARKER_REGEX = /\[CALL_OPENING_ACK\]/g;
 const END_CALL_MARKER_REGEX = /\[END_CALL\]/g;
+const TASK_STOP_MARKER_REGEX = /\[TASK:STOP\]/g;
 const HOLD_VERDICT_TOKEN_REGEX = /\[0\]/g;
 const ESCALATE_VERDICT_TOKEN_REGEX = /\[1\]/g;
 const MINIMIZE_ROOM_MARKER_REGEX = /\[-1\]/g;
@@ -217,6 +219,7 @@ export function stripInternalSpeechMarkers(text: string): string {
     .replace(CALL_OPENING_MARKER_REGEX, "")
     .replace(CALL_OPENING_ACK_MARKER_REGEX, "")
     .replace(END_CALL_MARKER_REGEX, "")
+    .replace(TASK_STOP_MARKER_REGEX, "")
     .replace(HOLD_VERDICT_TOKEN_REGEX, "")
     .replace(ESCALATE_VERDICT_TOKEN_REGEX, "")
     .replace(MINIMIZE_ROOM_MARKER_REGEX, "")
@@ -245,6 +248,7 @@ const CONTROL_MARKER_STRINGS = [
   "[CALL_OPENING]",
   "[CALL_OPENING_ACK]",
   "[END_CALL]",
+  TASK_STOP_MARKER,
   "[0]",
   "[1]",
   "[-1]",
@@ -354,12 +358,14 @@ export function createControlMarkerHoldback(
 
 /**
  * A session control a live-voice reply asked for with a terminal marker:
- * `end` from {@link END_CALL_MARKER}, `mute` from {@link MUTE_MARKER} or its
- * timed form, `updates` from the progress-cadence markers, `look_screen` and
- * `look_camera` and `look_stop` from the look markers.
+ * `end` from {@link END_CALL_MARKER}, `task_stop` from
+ * {@link TASK_STOP_MARKER}, `mute` from {@link MUTE_MARKER} or its timed form,
+ * `updates` from the progress-cadence markers, and the look actions from the
+ * look markers.
  */
 export type SessionControlRequest =
   | { readonly action: "end" }
+  | { readonly action: "task_stop" }
   | { readonly action: "mute"; readonly durationMs?: number }
   | { readonly action: "updates"; readonly cadence: "fewer" | "normal" }
   | { readonly action: "look_screen" }
@@ -367,7 +373,7 @@ export type SessionControlRequest =
   | { readonly action: "look_stop" };
 
 const TERMINAL_SESSION_CONTROL_REGEX =
-  /(\[END_CALL\]|\[UPDATES:(FEWER|NORMAL)\]|\[LOOK:(SCREEN|CAMERA|STOP)\]|\[MUTE\]|\[MUTE:\s*([^\]]*)\])\s*$/;
+  /(\[END_CALL\]|\[TASK:STOP\]|\[UPDATES:(FEWER|NORMAL)\]|\[LOOK:(SCREEN|CAMERA|STOP)\]|\[MUTE\]|\[MUTE:\s*([^\]]*)\])\s*$/;
 
 /**
  * The session control a reply ends with, or null.
@@ -392,6 +398,9 @@ export function parseTerminalSessionControl(
   if (match[1] === END_CALL_MARKER) {
     return { action: "end" };
   }
+  if (match[1] === TASK_STOP_MARKER) {
+    return { action: "task_stop" };
+  }
   if (match[2] !== undefined) {
     return {
       action: "updates",

package/src/calls/voice-session-bridge.ts

@@ -200,7 +200,10 @@ function frontDoorRuleWithDigest(
 function routingLegRuleFor(
   opts: Pick<
     VoiceTurnOptions,
-    "routingLeg" | "unifiedVerdict" | "spokenEscalationBridge"
+    | "routingLeg"
+    | "unifiedVerdict"
+    | "spokenEscalationBridge"
+    | "directEscalated"
   >,
   callerUtterance: string,
 ): string | null {
@@ -211,7 +214,9 @@ function routingLegRuleFor(
         callerUtterance,
       );
     case "escalated":
-      return escalatedContinuationRule(opts.spokenEscalationBridge);
+      return opts.directEscalated === true
+        ? null
+        : escalatedContinuationRule(opts.spokenEscalationBridge);
     default:
       return null;
   }
@@ -358,6 +363,7 @@ export interface VoiceRunEventSink {
     toolName: string,
     input: Record<string, unknown>,
     toolUseId?: string,
+    allowedToolNames?: ReadonlySet<string>,
   ): void;
   onToolResult(event: VoiceToolResultEvent): void;
 }
@@ -372,7 +378,11 @@ export interface VoiceTurnCallbacks {
   /** Fired when the agent run starts a definitive tool use this turn. */
   tool_use_start?: (
     toolName: string,
-    detail?: { toolUseId?: string; input?: Record<string, unknown> },
+    detail?: {
+      toolUseId?: string;
+      input?: Record<string, unknown>;
+      allowedToolNames?: ReadonlySet<string>;
+    },
   ) => void;
   /** Fired when a tool invocation finishes. */
   tool_result?: (event: VoiceToolResultEvent) => void;
@@ -533,6 +543,8 @@ export interface VoiceTurnOptions {
    * Only meaningful with `routingLeg: "escalated"`.
    */
   spokenEscalationBridge?: string;
+  /** Run the strong leg directly, without claiming a holding phrase was spoken. */
+  directEscalated?: boolean;
   /**
    * Marks this turn's `content` as an internal instruction rather than user
    * speech: it persists `hidden` so `/messages` filters it after a reload,
@@ -921,9 +933,13 @@ export async function startVoiceTurn(
     onError: (message) => {
       opts.onError?.(message);
     },
-    onToolUse: (toolName, input, toolUseId) => {
+    onToolUse: (toolName, input, toolUseId, allowedToolNames) => {
       log.debug({ toolName, input }, "Voice turn tool_use event");
-      opts.callbacks?.tool_use_start?.(toolName, { toolUseId, input });
+      opts.callbacks?.tool_use_start?.(toolName, {
+        toolUseId,
+        input,
+        ...(allowedToolNames !== undefined ? { allowedToolNames } : {}),
+      });
     },
     onToolResult: (event) => {
       opts.callbacks?.tool_result?.(event);
@@ -2081,7 +2097,12 @@ export async function startVoiceTurn(
           } else if (msg.type === "conversation_error") {
             eventSink.onError(msg.userMessage);
           } else if (msg.type === "tool_use_start") {
-            eventSink.onToolUse(msg.toolName, msg.input, msg.toolUseId);
+            eventSink.onToolUse(
+              msg.toolName,
+              msg.input,
+              msg.toolUseId,
+              conversation.allowedToolNames,
+            );
           } else if (msg.type === "tool_result") {
             eventSink.onToolResult({
               toolName: msg.toolName,

package/src/cli/commands/__tests__/plugins.test.ts

@@ -37,6 +37,7 @@ import type {
   InstallPluginOptions,
   InstallPluginResult,
 } from "../../lib/install-from-github.js";
+import type { PluginSearchMatch } from "../../lib/search-plugins.js";
 import type {
   PluginUpgradeResult,
   UpgradePluginDeps,
@@ -63,6 +64,7 @@ let stageFixture: ((stagingDir: string) => void) | null = null;
 let installPluginCalls: InstallPluginOptions[] = [];
 let platformInstallCalls: Array<{ name: string; force?: boolean }> = [];
 let upgradePluginCalls: UpgradePluginOptions[] = [];
+let catalogMatches: PluginSearchMatch[] = [];
 
 /**
  * Queued daemon IPC responses. The default (empty queue) is a transport
@@ -159,6 +161,10 @@ mock.module("../../lib/install-from-platform.js", () => ({
   },
 }));
 
+mock.module("../../lib/plugin-catalog-cache.js", () => ({
+  getPluginCatalog: async () => ({ ref: "main", matches: catalogMatches }),
+}));
+
 mock.module("../../lib/inspect-plugin.js", () => ({
   ...realInspect,
   inspectPlugin: async () => {
@@ -257,6 +263,7 @@ beforeEach(() => {
   installPluginCalls = [];
   platformInstallCalls = [];
   upgradePluginCalls = [];
+  catalogMatches = [];
   ipcResults = [];
   inspectResult = null;
   installTarget = null;
@@ -433,6 +440,32 @@ describe("plugins install - declared-schedules consent", () => {
     expect(r.stdout).toContain('Plugin "caveman" declares 2 schedules:');
     expect(r.exitCode).toBe(0);
   });
+
+  test("a local catalog source bypasses the platform installer", async () => {
+    catalogMatches = [
+      {
+        name: "fathom",
+        path: "local:plugins/mcp-catalog/fathom@1.0.0",
+        category: "productivity",
+        source: {
+          kind: "local",
+          path: "plugins/mcp-catalog/fathom",
+          version: "1.0.0",
+        },
+      },
+    ];
+
+    const r = await runCommand(["plugins", "install", "fathom"]);
+
+    expect(platformInstallCalls).toHaveLength(0);
+    expect(installPluginCalls).toHaveLength(1);
+    expect(installPluginCalls[0]?.trustedSource).toEqual({
+      kind: "local",
+      path: "plugins/mcp-catalog/fathom",
+      version: "1.0.0",
+    });
+    expect(r.exitCode).toBe(0);
+  });
 });
 
 describe("plugins upgrade - declared-schedules consent (local fallback)", () => {
@@ -701,6 +734,39 @@ describe("plugins inspect - schedules surface", () => {
     expect(r.stdout).toContain("weekly  RRULE:FREQ=WEEKLY;BYDAY=MO  (execute)");
     expect(r.exitCode).toBe(0);
   });
+
+  test("renders a bundled package location without a GitHub URL", async () => {
+    inspectResult = {
+      ...inspectionWithSurfaces({
+        skills: [],
+        hooks: [],
+        tools: [],
+        schedules: [],
+      }),
+      installed: false,
+      status: "not-installed",
+      local: null,
+      remote: {
+        kind: "local",
+        repo: "",
+        path: "plugins/mcp-catalog/fathom",
+        commit: "1.0.0",
+        committedAt: null,
+        description: null,
+        homepage: null,
+        license: null,
+        category: "productivity",
+        marketplaceRef: "main",
+        version: "1.0.0",
+      },
+    };
+
+    const r = await runCommand(["plugins", "inspect", "fathom"]);
+
+    expect(r.stdout).toContain("bundled:plugins/mcp-catalog/fathom");
+    expect(r.stdout).not.toContain("https://github.com//");
+    expect(r.exitCode).toBe(0);
+  });
 });
 
 describe("plugins install - setup skill hint", () => {

package/src/cli/commands/plugins.ts

@@ -235,11 +235,29 @@ export function registerPluginsCommand(program: Command): void {
               // pinned commit. With platform features disabled (air-gapped /
               // self-hosted) there is no platform to call, so resolve the pin
               // from the bundled catalog and install through the GitHub path.
-              if (libs.catalogLocal.arePlatformFeaturesEnabled()) {
-                result = await libs.installPlatform.installPluginViaPlatform(
-                  { name: nameOrUrl, force: opts.force },
-                  { fetch: globalThis.fetch.bind(globalThis), confirmStaged },
-                );
+              const platformEnabled =
+                libs.catalogLocal.arePlatformFeaturesEnabled();
+              if (platformEnabled) {
+                const match = (
+                  await libs.catalogCache.getPluginCatalog(DEFAULT_PLUGIN_REF, {
+                    fetch: globalThis.fetch.bind(globalThis),
+                  })
+                ).matches.find((candidate) => candidate.name === nameOrUrl);
+                if (match?.source.kind === "local") {
+                  result = await libs.installGitHub.installPlugin(
+                    {
+                      name: nameOrUrl,
+                      force: opts.force,
+                      trustedSource: match.source,
+                    },
+                    { fetch: globalThis.fetch.bind(globalThis), confirmStaged },
+                  );
+                } else {
+                  result = await libs.installPlatform.installPluginViaPlatform(
+                    { name: nameOrUrl, force: opts.force },
+                    { fetch: globalThis.fetch.bind(globalThis), confirmStaged },
+                  );
+                }
               } else {
                 const source =
                   libs.catalogLocal.resolveBundledPluginSource(nameOrUrl);
@@ -250,19 +268,30 @@ export function registerPluginsCommand(program: Command): void {
                   process.exitCode = 1;
                   return;
                 }
-                result = await libs.installGitHub.installPlugin(
-                  {
-                    name: nameOrUrl,
-                    force: opts.force,
-                    trustedSource: {
-                      owner: source.owner,
-                      repo: source.repo,
-                      rootPath: source.path,
-                      ref: source.ref,
+                if (source.kind === "local") {
+                  result = await libs.installGitHub.installPlugin(
+                    {
+                      name: nameOrUrl,
+                      force: opts.force,
+                      trustedSource: source,
                     },
-                  },
-                  { fetch: globalThis.fetch.bind(globalThis), confirmStaged },
-                );
+                    { fetch: globalThis.fetch.bind(globalThis), confirmStaged },
+                  );
+                } else {
+                  result = await libs.installGitHub.installPlugin(
+                    {
+                      name: nameOrUrl,
+                      force: opts.force,
+                      trustedSource: {
+                        owner: source.owner,
+                        repo: source.repo,
+                        rootPath: source.path,
+                        ref: source.ref,
+                      },
+                    },
+                    { fetch: globalThis.fetch.bind(globalThis), confirmStaged },
+                  );
+                }
               }
             } else {
               const installOpts = direct
@@ -1390,8 +1419,11 @@ function driftLine(changes: FingerprintComparison | null): string {
   return parts.join(", ");
 }
 
-/** Build the GitHub web URL for a remote pin's location (repo, or repo subtree). */
+/** Build the display location for a bundled package or GitHub pin. */
 function remoteLocation(remote: PluginRemoteInfo): string {
+  if (remote.kind === "local") {
+    return `bundled:${remote.path}`;
+  }
   const base = `https://github.com/${remote.repo}`;
   return remote.path ? `${base}/tree/${remote.commit}/${remote.path}` : base;
 }

package/src/cli/lib/__tests__/install-from-github.test.ts

@@ -253,6 +253,73 @@ describe("installPlugin — install lifecycle", () => {
     rmSync(ws, { recursive: true, force: true });
   });
 
+  test("installs a bundled standard package and discovers its MCP server", async () => {
+    const result = await installPlugin(
+      {
+        name: "fathom",
+        trustedSource: {
+          kind: "local",
+          path: "plugins/mcp-catalog/fathom",
+          version: "1.0.0",
+        },
+      },
+      {
+        fetch: (async () => {
+          throw new Error("local package install must not fetch");
+        }) as FetchLike,
+        runGit: unusedGitRunner,
+        workspacePluginsDir: pluginsDir,
+        materializeLocalPackage: (path, version, destination) => {
+          expect(path).toBe("plugins/mcp-catalog/fathom");
+          expect(version).toBe("1.0.0");
+          writeFileSync(
+            join(destination, "plugin.json"),
+            JSON.stringify({
+              $schema:
+                "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+              name: "fathom",
+              version: "1.0.0",
+            }),
+          );
+          writeFileSync(
+            join(destination, "mcp.json"),
+            JSON.stringify({
+              $schema:
+                "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+              mcpServers: {
+                fathom: {
+                  type: "streamable-http",
+                  url: "https://api.fathom.ai/mcp",
+                },
+              },
+            }),
+          );
+          return 2;
+        },
+      },
+    );
+
+    expect(result).toMatchObject({
+      name: "fathom",
+      fileCount: 2,
+      ref: "1.0.0",
+      commit: null,
+    });
+    expect(readInstallMeta(result.target)?.source).toEqual({
+      kind: "local",
+      path: "plugins/mcp-catalog/fathom",
+      version: "1.0.0",
+    });
+    expect(
+      readPluginMcpServers({ workspacePluginsDir: pluginsDir }).servers,
+    ).toEqual([
+      expect.objectContaining({
+        pluginName: "fathom",
+        serverKey: "fathom",
+      }),
+    ]);
+  });
+
   test("refuses to overwrite an existing install without --force", async () => {
     // GIVEN a plugin already installed at <pluginsDir>/caveman
     const target = join(pluginsDir, "caveman");