@vellumai/assistant 0.12.3 → 0.12.4-dev.202609231620.a15f321

package/src/api/events/tool-result.ts

@@ -54,6 +54,7 @@ export const WebSearchProviderIdSchema = z.enum([
   "fastcrw",
   "searxng",
   "tinyfish",
+  "exa",
 ]);
 
 export type WebSearchProviderId = z.infer<typeof WebSearchProviderIdSchema>;
@@ -112,6 +113,16 @@ export const WebFetchMetadataSchema = z.object({
   durationMs: z.number(),
   errorMessage: z.string().optional(),
   mayRequireJavaScript: z.boolean().optional(),
+  /**
+   * The requested `start_index` was past the end of the page, so nothing was
+   * read. Always set, true or false, by an assistant whose metadata carries
+   * every warning a reader acts on (this and `providerWarning` included); a
+   * record without it came from one that predates them, whose remaining
+   * warnings are only in the result text.
+   */
+  startIndexPastEnd: z.boolean().optional(),
+  /** A hosted provider's own warning about the fetch, verbatim. */
+  providerWarning: z.string().optional(),
 });
 
 export type WebFetchMetadata = z.infer<typeof WebFetchMetadataSchema>;

package/src/api/index.ts

@@ -1,5 +1,10 @@
 import { z } from "zod";
 
+export {
+  type AskQuestionInput,
+  AskQuestionInputSchema,
+  type RecordedQuestion,
+} from "./ask-question-tool.js";
 export {
   isComputerUseToolCall,
   resolveComputerUseToolName,
@@ -832,6 +837,8 @@ export {
   FeedItemStatusSchema,
   type FeedItemType,
   FeedItemTypeSchema,
+  type FeedItemUpdate,
+  FeedItemUpdateSchema,
   type FeedItemUrgency,
   FeedItemUrgencySchema,
   GUARDIAN_TERMINAL_REASON_SUPERSEDED,

package/src/api/requests/dictation.ts

@@ -1,8 +1,8 @@
 /**
  * Wire contract for the dictation REST endpoint (`POST /dictation`).
  *
- * The body web/macOS sends when asking the daemon to clean up a raw voice
- * transcript and classify it as dictation vs. action. `context` is its own
+ * The body web/macOS sends to apply explicit dictation replacements, classify
+ * voice input, or edit selected text. `context` is its own
  * named schema/type so consumers (web client) can import `DictationContext`
  * directly instead of inferring it from the generated client.
  *

package/src/api/responses/home.ts

@@ -167,6 +167,28 @@ export type FeedItemGuardianRequest = z.infer<
   typeof FeedItemGuardianRequestSchema
 >;
 
+/**
+ * One background rewrite of a managed skill, as a receipt item lists it.
+ *
+ * A receipt (`detailPanel.kind === "updatesList"`) collapses every skill
+ * update a background pass made within one burst into a single feed item, and
+ * `updates` keeps each rewrite whole: the skill it touched, the pass's own
+ * account of what changed, and the conversation the change came from, when
+ * lineage resolved. The same skill can appear more than once, one entry per
+ * rewrite, in the order the rewrites happened. Clients group on `skillId`
+ * alone, never on `name` or the summary text.
+ */
+export const FeedItemUpdateSchema = z.object({
+  skillId: z.string(),
+  /** The skill's display name at the time of the rewrite. */
+  name: z.string(),
+  /** The pass's own account of what it changed. Plain text, not markdown. */
+  summary: z.string(),
+  /** The conversation the rewrite was distilled from, when it resolved. */
+  conversationId: z.string().optional(),
+});
+export type FeedItemUpdate = z.infer<typeof FeedItemUpdateSchema>;
+
 /**
  * A single item rendered in the Home feed.
  *
@@ -198,6 +220,11 @@ export const FeedItemSchema = z.object({
   // Present only on the canonical "Needs attention" item projecting a
   // guardian request; see FeedItemGuardianRequestSchema.
   guardianRequest: FeedItemGuardianRequestSchema.optional(),
+  // Present only on a skill-update receipt (`detailPanel.kind` is
+  // `updatesList`); see FeedItemUpdateSchema. `summary` still carries the
+  // same content as a plain list, so a client without the panel loses only
+  // the per-skill links.
+  updates: z.array(FeedItemUpdateSchema).optional(),
   category: FeedItemCategorySchema.optional(),
   noteworthy: z.boolean().optional(),
   fromAssistant: z.boolean().optional(),

package/src/avatar/notification-avatar.test.ts

@@ -63,9 +63,6 @@ const TRAITS = { bodyShape: "blob", eyeStyle: "curious", color: "green" };
 const GREEN_DISC = { r: 0xe6, g: 0xf1, b: 0xe7 };
 /** #E9642F mixed 14% into white. */
 const ORANGE_DISC = { r: 0xfc, g: 0xe9, b: 0xe2 };
-/** The neutral disc every accent-less avatar wears. */
-const FALLBACK_DISC = { r: 0xec, g: 0xef, b: 0xea };
-
 /** On the disc and clear of the inset avatar square, which starts at y = 28.16. */
 const DISC_SAMPLE = { x: 128, y: 8 };
 /** Outside the inscribed disc, where the render leaves nothing at all. */
@@ -233,7 +230,7 @@ describe("renderNotificationAvatarPng", () => {
   );
 
   nativeTest(
-    "renders an uploaded image on the neutral disc when it has no accent",
+    "fills the circle with an uploaded image when it has no accent",
     async () => {
       await writeUpload("png", null);
 
@@ -245,7 +242,9 @@ describe("renderNotificationAvatarPng", () => {
       expect(image.height).toBe(256);
       expect(image.at(CORNER.x, CORNER.y).a).toBe(0);
       expect(image.at(DISC_SAMPLE.x, DISC_SAMPLE.y)).toEqual({
-        ...FALLBACK_DISC,
+        r: 0x20,
+        g: 0x60,
+        b: 0xc0,
         a: 255,
       });
       expect(image.at(128, 128)).toEqual({ r: 0x20, g: 0x60, b: 0xc0, a: 255 });
@@ -253,23 +252,34 @@ describe("renderNotificationAvatarPng", () => {
     NATIVE_RENDER_TEST_TIMEOUT_MS,
   );
 
-  nativeTest(
-    "cover-crops a wide upload and clips it to the disc",
-    async () => {
-      // 4:1, so a letterboxing render would leave disc colour above and below
-      // the avatar inside the inset square.
-      await writeUpload("png", null, { width: 256, height: 64 });
-
-      const image = await pixels((await renderNotificationAvatarPng())!);
-      // Inside the inset square (which starts at 28.16) near its top edge:
-      // filled by a cover-crop, disc colour by a letterbox.
-      expect(image.at(128, 35)).toEqual({ r: 0x20, g: 0x60, b: 0xc0, a: 255 });
-      // Inside the inset square but outside the disc, so only the clip can
-      // keep the avatar out of it.
-      expect(image.at(30, 30).a).toBe(0);
-    },
-    NATIVE_RENDER_TEST_TIMEOUT_MS,
-  );
+  for (const [shape, width, height] of [
+    ["landscape", 256, 64],
+    ["portrait", 64, 256],
+  ] as const) {
+    nativeTest(
+      `cover-crops a ${shape} upload to the full disc`,
+      async () => {
+        await writeUpload("png", null, { width, height });
+
+        const image = await pixels((await renderNotificationAvatarPng())!);
+        for (const [x, y] of [
+          [128, 8],
+          [8, 128],
+          [128, 248],
+          [248, 128],
+        ]) {
+          expect(image.at(x!, y!)).toEqual({
+            r: 0x20,
+            g: 0x60,
+            b: 0xc0,
+            a: 255,
+          });
+        }
+        expect(image.at(30, 30).a).toBe(0);
+      },
+      NATIVE_RENDER_TEST_TIMEOUT_MS,
+    );
+  }
 
   nativeTest(
     "transcodes a WebP upload, which resvg cannot decode on its own",
@@ -281,20 +291,18 @@ describe("renderNotificationAvatarPng", () => {
 
       const image = await pixels(png!);
       expect(image.at(CORNER.x, CORNER.y).a).toBe(0);
-      expect(image.at(DISC_SAMPLE.x, DISC_SAMPLE.y)).toEqual({
-        ...FALLBACK_DISC,
-        a: 255,
-      });
       // WebP is lossy, so the transcode moves the flat fill by a channel step
       // or two; what matters is that the avatar is drawn at all.
-      const centre = image.at(128, 128);
-      expect(centre.a).toBe(255);
-      for (const [actual, expected] of [
-        [centre.r, 0x20],
-        [centre.g, 0x60],
-        [centre.b, 0xc0],
-      ]) {
-        expect(Math.abs(actual! - expected!)).toBeLessThanOrEqual(4);
+      for (const point of [{ x: 128, y: 128 }, DISC_SAMPLE]) {
+        const pixel = image.at(point.x, point.y);
+        expect(pixel.a).toBe(255);
+        for (const [actual, expected] of [
+          [pixel.r, 0x20],
+          [pixel.g, 0x60],
+          [pixel.b, 0xc0],
+        ]) {
+          expect(Math.abs(actual! - expected!)).toBeLessThanOrEqual(4);
+        }
       }
     },
     NATIVE_RENDER_TEST_TIMEOUT_MS,

package/src/avatar/notification-avatar.ts

@@ -222,6 +222,7 @@ export async function renderNotificationAvatarPng(
     const Resvg = getResvg();
     const resvg = new Resvg(
       notificationAvatarSvg({
+        kind: state.kind,
         innerPngBase64: source.bytes.toString("base64"),
         innerMediaType: source.mediaType,
         accentHex: resolveNotificationAccentHex(state),

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

@@ -143,6 +143,10 @@ mock.module("../../persistence/conversation-crud.js", () => ({
   recordConversationPersistedSeq: () => {},
 }));
 
+import {
+  clearHubClients,
+  registerHubClient,
+} from "../../__tests__/helpers/hub-clients.js";
 import { setConfig } from "../../__tests__/helpers/set-config.js";
 import type { PreparedModelCall } from "../../agent/loop.js";
 import { selectWinningProfile } from "../../config/llm-resolver.js";
@@ -2326,21 +2330,30 @@ describe("front-door leg tool suppression", () => {
 });
 
 describe("desktop skill preactivation", () => {
+  afterEach(() => clearHubClients(assistantEventHub));
+
   async function preactivatedFor(turn: Record<string, unknown>): Promise<{
     skillIds: string[];
     proxyInterfaces: unknown[];
     skillIdsDuringLoop: string[];
+    promptDuringLoop: string | null;
   }> {
     const skillIds: string[] = [];
     const proxyInterfaces: unknown[] = [];
     let skillIdsDuringLoop: string[] = [];
+    let prompt: string | null = null;
+    let promptDuringLoop: string | null = null;
     const fake = makeFakeConversation({
       processing: false,
       runAgentLoop: async () => {
         skillIdsDuringLoop = [...skillIds];
+        promptDuringLoop = prompt;
       },
     });
     Object.assign(fake.conversation, {
+      setVoiceCallControlPrompt: (value: string | null) => {
+        prompt = value;
+      },
       addPreactivatedSkillId: (id: string) => {
         skillIds.push(id);
       },
@@ -2356,9 +2369,58 @@ describe("desktop skill preactivation", () => {
       ...turn,
     });
     await flushMicrotasks();
-    return { skillIds, proxyInterfaces, skillIdsDuringLoop };
+    return { skillIds, proxyInterfaces, skillIdsDuringLoop, promptDuringLoop };
   }
 
+  test("a shared-screen turn receives the annotation instructions and schemas before inference", async () => {
+    registerHubClient({
+      hub: assistantEventHub,
+      clientId: "annotation-client",
+      interfaceId: "macos",
+      actorPrincipalId: "user-123",
+      capabilities: ["host_cu", "host_cu_annotate"],
+    });
+    const result = await preactivatedFor({
+      routingLeg: "escalated",
+      macosDesktopSession: true,
+      screenSharing: true,
+      actorPrincipalId: "user-123",
+    });
+    expect(result.skillIdsDuringLoop).toContain("screen-annotation");
+    expect(result.promptDuringLoop).toContain("ID: screen-annotation");
+    expect(result.promptDuringLoop).toContain("Name the thing.");
+    expect(result.promptDuringLoop).toContain("screen_point_at");
+    expect(result.promptDuringLoop).toContain("screen_clear_marks");
+    expect(result.promptDuringLoop).toContain('"target"');
+    expect(result.promptDuringLoop).toContain("skill_execute");
+  });
+
+  test.each([
+    { screenSharing: false },
+    { actorPrincipalId: "other-user" },
+    { routingLeg: "front-door" },
+    { macosDesktopSession: false },
+  ])(
+    "does not preload annotation for an ineligible turn: %j",
+    async (override) => {
+      registerHubClient({
+        hub: assistantEventHub,
+        clientId: "annotation-client",
+        interfaceId: "macos",
+        actorPrincipalId: "user-123",
+        capabilities: ["host_cu", "host_cu_annotate"],
+      });
+      const result = await preactivatedFor({
+        routingLeg: "escalated",
+        macosDesktopSession: true,
+        screenSharing: true,
+        actorPrincipalId: "user-123",
+        ...override,
+      });
+      expect(result.promptDuringLoop).not.toContain("ID: screen-annotation");
+    },
+  );
+
   test("an escalated leg of a macOS desktop session starts with computer use active", async () => {
     const result = await preactivatedFor({
       routingLeg: "escalated",

package/src/calls/voice-escalation-judge.ts

@@ -9,15 +9,16 @@
  * correct reply need something the front door cannot do from here? A
  * confident yes overrules a front-door answer and hands the turn off.
  *
- * The judge runs only when the `voiceEscalationJudge` call site resolves to
- * the TypeSafe provider. Every other outcome (no such profile, provider
- * error, timeout, unparseable answer) is a "clear" verdict, so the front
- * door's own decision stands exactly as it would without the judge.
+ * The judge uses managed Jev by default when Vellum-managed inference is
+ * available. An explicit TypeSafe call-site override can use a user-owned
+ * connection. Every other outcome (unavailable route, provider error,
+ * timeout, unparseable answer) is a "clear" verdict, so the front door's own
+ * decision stands exactly as it would without the judge.
  */
 
+import { askTypesafeNoul } from "../providers/jev/ask.js";
 import type { Message, Provider } from "../providers/types.js";
 import { safeStringSlice } from "../util/unicode.js";
-import { askTypesafeNoul } from "./typesafe-noul.js";
 
 export const VOICE_ESCALATION_JUDGE_CALL_SITE = "voiceEscalationJudge";
 

package/src/calls/voice-screen-annotation.ts

@@ -0,0 +1,44 @@
+import { shouldAttachHostProxyForCapability } from "../daemon/host-proxy-preactivation.js";
+import { skillLoadTool } from "../tools/skills/load.js";
+import type { ToolContext } from "../tools/types.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("voice-screen-annotation");
+
+export async function loadVoiceScreenAnnotation(
+  context: ToolContext,
+): Promise<string | null> {
+  if (
+    !shouldAttachHostProxyForCapability(
+      "host_cu_annotate",
+      context.transportInterface,
+      context.sourceActorPrincipalId,
+    )
+  ) {
+    return null;
+  }
+  try {
+    const result = await skillLoadTool.execute(
+      { skill: "screen-annotation" },
+      context,
+      { readOnly: true },
+    );
+    if (result.isError) {
+      log.warn(
+        { conversationId: context.conversationId, error: result.content },
+        "Could not preload screen annotation",
+      );
+      return null;
+    }
+    return [
+      "The user is sharing their screen. skill_load has automatically loaded screen-annotation for this turn. Use its tools through skill_execute when pointing at the shared screen.",
+      result.content,
+    ].join("\n\n");
+  } catch (err) {
+    log.warn(
+      { err, conversationId: context.conversationId },
+      "Could not preload screen annotation",
+    );
+    return null;
+  }
+}

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

@@ -32,7 +32,9 @@ import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.js";
 import type { ModeSessionSourceHandle } from "../daemon/conversation-mode-session.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
+import { getEffectiveEnabledPluginSet } from "../daemon/conversation-tool-setup.js";
 import { preactivateHostProxySkills } from "../daemon/host-proxy-preactivation.js";
+import { resolveTrustClass } from "../daemon/trust-context.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
   newestPersistedSightFrame,
@@ -78,6 +80,7 @@ import {
 } from "./voice-control-protocol.js";
 import { judgeEscalation } from "./voice-escalation-judge.js";
 import type { VoiceEscalationTarget } from "./voice-escalation-target.js";
+import { loadVoiceScreenAnnotation } from "./voice-screen-annotation.js";
 import {
   createFrontDoorStreamGate,
   escalatedContinuationRule,
@@ -452,6 +455,8 @@ export interface VoiceTurnOptions {
    * session reports `macos` for its channel capabilities, iOS included.
    */
   macosDesktopSession?: boolean;
+  /** The desktop client currently shares a surface with this voice session. */
+  screenSharing?: boolean;
   /** Whether this is an inbound call (no outbound task). */
   isInbound: boolean;
   /** The outbound call task, if any. */
@@ -2108,6 +2113,23 @@ export async function startVoiceTurn(
           sourceInterface,
           sourceActorPrincipalId,
         );
+        if (opts.screenSharing === true) {
+          const annotation = await loadVoiceScreenAnnotation({
+            conversationId: opts.conversationId,
+            workingDir: conversation.workingDir,
+            trustClass: resolveTrustClass(opts.trustContext),
+            transportInterface: sourceInterface,
+            clientOs: "macos",
+            enabledPluginSet: getEffectiveEnabledPluginSet(conversation),
+            sourceActorPrincipalId,
+            signal: opts.signal,
+          });
+          if (annotation !== null) {
+            conversation.setVoiceCallControlPrompt(
+              [voiceCallControlPrompt, annotation].filter(Boolean).join("\n\n"),
+            );
+          }
+        }
       }
       await conversation.runAgentLoop(persistedContent, messageId, {
         ...(opts.subagentNotification?.cronRunId

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

@@ -66,6 +66,20 @@ let platformInstallCalls: Array<{ name: string; force?: boolean }> = [];
 let upgradePluginCalls: UpgradePluginOptions[] = [];
 let catalogMatches: PluginSearchMatch[] = [];
 let catalogError: Error | null = null;
+const CATALOG_COMMIT = "a".repeat(40);
+
+function githubCatalogMatch(name: string): PluginSearchMatch {
+  return {
+    name,
+    path: `github:example-org/${name}@${CATALOG_COMMIT}`,
+    category: null,
+    source: {
+      kind: "github",
+      repo: `example-org/${name}`,
+      ref: CATALOG_COMMIT,
+    },
+  };
+}
 
 /**
  * Queued daemon IPC responses. The default (empty queue) is a transport
@@ -269,7 +283,10 @@ beforeEach(() => {
   installPluginCalls = [];
   platformInstallCalls = [];
   upgradePluginCalls = [];
-  catalogMatches = [];
+  catalogMatches = [
+    githubCatalogMatch("example"),
+    githubCatalogMatch("imessage"),
+  ];
   catalogError = null;
   ipcResults = [];
   inspectResult = null;
@@ -485,6 +502,17 @@ describe("plugins install - declared-schedules consent", () => {
     ]);
     expect(r.exitCode).toBe(0);
   });
+
+  test("does not use the outage fallback for a gated integration", async () => {
+    catalogError = new Error("catalog unavailable");
+
+    const r = await runCommand(["plugins", "install", "gamma"]);
+
+    expect(installPluginCalls).toHaveLength(0);
+    expect(platformInstallCalls).toHaveLength(0);
+    expect(r.stderr).toContain("not in the marketplace catalog");
+    expect(r.exitCode).toBe(1);
+  });
 });
 
 describe("plugins upgrade - declared-schedules consent (local fallback)", () => {

package/src/cli/commands/channel-verification-sessions.help.ts

@@ -44,7 +44,11 @@ Examples:
           description:
             "Destination address for outbound verification (handle, phone number, user ID, or email address)",
         },
-        { flags: "--rebind", description: "Replace existing guardian binding" },
+        {
+          flags: "--rebind",
+          description:
+            "Create a code although the channel already has a guardian (see below)",
+        },
         {
           flags: "--conversation-id <conversationId>",
           description: "Conversation ID for inbound challenges",
@@ -74,7 +78,13 @@ Routes between three creation modes based on the provided options:
   2. Outbound: --channel <ch> --destination <dest>
      Sends a verification code to the given destination. Supports telegram
      (handle or chat ID), phone (E.164 number), slack and discord (user ID),
-     and email. Use --rebind to replace an existing guardian binding.
+     and email.
+
+--rebind creates a code although the channel already has a guardian. On
+telegram, slack, discord and email, only the account already bound can redeem
+that code, which is how the same guardian verifies again. A code never moves
+the guardian to a different account there: run "revoke" first, then create
+without --rebind. On phone, an outbound code replaces the bound number.
 
   3. Inbound: --channel <ch> (no --destination)
      Generates a challenge secret for the guardian to send back on the

package/src/cli/commands/platform/index.help.ts

@@ -55,7 +55,8 @@ Fields:
   isPlatform          Whether IS_PLATFORM is set (boolean)
   baseUrl             VELLUM_PLATFORM_URL — the platform gateway base URL
   assistantId         This assistant's platform UUID
-  hasAssistantApiKey  Whether a stored assistant API key is available
+  hasAssistantApiKey  Whether a stored assistant API key is available; null
+                      when the credential store could not be read
   hasWebhookSecret    Whether a stored webhook secret is available (needed
                       for email and other inbound webhook channels)
   available           Whether callback registration prerequisites are satisfied

package/src/cli/commands/platform/index.ts

@@ -24,7 +24,7 @@ interface PlatformStatusResult {
   isPlatform: boolean;
   baseUrl: string;
   assistantId: string;
-  hasAssistantApiKey: boolean;
+  hasAssistantApiKey: boolean | null;
   hasWebhookSecret: boolean;
   available: boolean;
   organizationId: string | null;
@@ -95,7 +95,13 @@ export function registerPlatformCommand(program: Command): void {
             log.info(`Base URL: ${result.baseUrl || "(not set)"}`);
             log.info(`Assistant ID: ${result.assistantId || "(not set)"}`);
             log.info(
-              `Assistant API key: ${result.hasAssistantApiKey ? "set" : "not set"}`,
+              `Assistant API key: ${
+                result.hasAssistantApiKey === null
+                  ? "unknown (credential store unreachable)"
+                  : result.hasAssistantApiKey
+                    ? "set"
+                    : "not set"
+              }`,
             );
             log.info(
               `Webhook secret: ${result.hasWebhookSecret ? "set" : "not set (run ensure-registration to provision)"}`,

package/src/cli/commands/plugins.ts

@@ -238,7 +238,15 @@ export function registerPluginsCommand(program: Command): void {
               const platformEnabled =
                 libs.catalogLocal.arePlatformFeaturesEnabled();
               if (platformEnabled) {
+                if (!libs.catalogLocal.isPluginCatalogEntryVisible(nameOrUrl)) {
+                  console.error(
+                    `Plugin "${nameOrUrl}" is not in the marketplace catalog.`,
+                  );
+                  process.exitCode = 1;
+                  return;
+                }
                 let match;
+                let catalogResolved = false;
                 try {
                   match = (
                     await libs.catalogCache.getPluginCatalog(
@@ -246,10 +254,18 @@ export function registerPluginsCommand(program: Command): void {
                       { fetch: globalThis.fetch.bind(globalThis) },
                     )
                   ).matches.find((candidate) => candidate.name === nameOrUrl);
+                  catalogResolved = true;
                 } catch {
                   // The install endpoint remains authoritative and can succeed
                   // independently when catalog discovery is unavailable.
                 }
+                if (!match && catalogResolved) {
+                  console.error(
+                    `Plugin "${nameOrUrl}" is not in the marketplace catalog.`,
+                  );
+                  process.exitCode = 1;
+                  return;
+                }
                 if (match?.source.kind === "local") {
                   result = await libs.installGitHub.installPlugin(
                     {

package/src/cli/lib/__tests__/inspect-plugin.test.ts

@@ -306,6 +306,35 @@ describe("inspectPlugin", () => {
     expect(result.remote?.commit).toBe(SHA_B);
   });
 
+  test("hides an uninstalled gated integration without fetching the marketplace", async () => {
+    let fetchCalls = 0;
+    const fetch = (async () => {
+      fetchCalls += 1;
+      return new Response("unexpected request", { status: 500 });
+    }) as FetchLike;
+
+    await expect(
+      inspectPlugin(
+        { name: "gamma" },
+        { fetch, workspacePluginsDir: workspace },
+      ),
+    ).rejects.toBeInstanceOf(PluginInspectNotFoundError);
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("keeps an installed gated integration inspectable", async () => {
+    installPlugin(workspace, "gamma", { sidecar: null });
+    const fetch = makeFetch({ marketplace: manifestWith("gamma", SHA_B) });
+
+    const result = await inspectPlugin(
+      { name: "gamma" },
+      { fetch, workspacePluginsDir: workspace },
+    );
+
+    expect(result.installed).toBe(true);
+    expect(result.local?.description).toBe("Installed copy.");
+  });
+
   test("previews an uninstalled bundled provider offline without fetching GitHub", async () => {
     const savedDisablePlatform = process.env.VELLUM_DISABLE_PLATFORM;
     const savedIsPlatform = process.env.IS_PLATFORM;