@vellumai/assistant 0.12.2-staging.2 → 0.12.2-staging.3

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

@@ -67,9 +67,8 @@ mock.module("../../../util/logger.js", () => ({
 // Import module under test (after mocks)
 // ---------------------------------------------------------------------------
 
-const { formatBrowserStatusLines, registerBrowserCommand } = await import(
-  "../browser.js"
-);
+const { formatBrowserStatusLines, registerBrowserCommand } =
+  await import("../browser.js");
 
 // ---------------------------------------------------------------------------
 // Test helper
@@ -641,3 +640,85 @@ describe("error exit codes", () => {
     expect(exitCode).toBe(0);
   });
 });
+
+for (const desktopFlag of ["--virtual-desktop", "--desktop"]) {
+  describe(`virtual desktop routing via ${desktopFlag}`, () => {
+    test("routes semantic actions through IPC with conversation and element identity", async () => {
+      process.env.__CONVERSATION_ID = "conv-desktop";
+      const result = await runCommand([
+        "browser",
+        desktopFlag,
+        "--json",
+        "click",
+        "--element-id",
+        "e7",
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(lastIpcCall?.method).toBe("browser_execute");
+      expect(lastBody()).toMatchObject({
+        desktop: true,
+        conversationId: "conv-desktop",
+        operation: "click",
+        input: { element_id: "e7" },
+      });
+      expect(
+        (lastBody().input as Record<string, unknown>).desktop,
+      ).toBeUndefined();
+    });
+
+    test.each([
+      { args: ["list"] },
+      { args: ["select", "--tab-id", "7"] },
+      { args: ["new"] },
+      { args: ["close", "--tab-id", "7"] },
+    ])("routes desktop tabs $args through IPC", async ({ args }) => {
+      mockIpcResult = { ok: true, result: { ok: true, tabs: [] } };
+      const result = await runCommand([
+        "browser",
+        desktopFlag,
+        "--json",
+        "tabs",
+        ...args,
+      ]);
+      expect(result.exitCode).toBe(0);
+      expect(lastIpcCall?.method).toBe("browser_tabs");
+      expect(lastBody()).toMatchObject({ desktop: true, command: args[0] });
+    });
+
+    test.each([
+      { flags: ["--browser-mode", "extension"] },
+      { flags: ["--target-client-id", "client-123"] },
+    ])("rejects conflicting desktop targets before IPC", async ({ flags }) => {
+      const result = await runCommand([
+        "browser",
+        desktopFlag,
+        ...flags,
+        "tabs",
+        "list",
+      ]);
+      expect(result.exitCode).not.toBe(0);
+      expect(lastIpcCall).toBeNull();
+    });
+  });
+}
+
+test.each([
+  { args: ["list"] },
+  { args: ["select", "--tab-id", "1"] },
+  { args: ["new", "--url", "https://example.com"] },
+  { args: ["close", "--tab-id", "1"] },
+])(
+  "tab command $args forwards an explicit backend override",
+  async ({ args }) => {
+    mockIpcResult = { ok: true, result: { ok: true, tabs: [] } };
+    await runCommand([
+      "browser",
+      "--browser-mode",
+      "extension",
+      "tabs",
+      ...args,
+    ]);
+    expect(lastIpcCall?.method).toBe("browser_tabs");
+    expect(lastBody().browserMode).toBe("extension");
+  },
+);

package/src/cli/commands/browser.help.ts

@@ -96,6 +96,15 @@ export const browserHelp: CliCommandHelp = {
   name: "browser",
   description: "Control the browser via the running assistant.",
   options: [
+    {
+      flags: "--desktop",
+      description: "Compatibility alias for --virtual-desktop.",
+    },
+    {
+      flags: "--virtual-desktop",
+      description:
+        "Use Chrome in the platform-hosted virtual desktop with visible cursor feedback.",
+    },
     {
       flags: "--session <id>",
       description: "Session ID to preserve browser state across invocations.",
@@ -118,6 +127,38 @@ export const browserHelp: CliCommandHelp = {
   ],
   helpText: `
 Browser operations are executed through the running assistant.
+Virtual desktop is available only for platform-hosted assistants.
+In the web client, automatic selection prefers virtual desktop Chrome when
+its feature is enabled and the conversation has an
+identified guardian. The macOS and Windows apps keep their existing browser
+selection and fallback behavior; use --virtual-desktop to select it there.
+Existing sessions and explicit backend/client choices take priority.
+--browser-mode local (alias playwright) means the assistant's Playwright browser,
+not the user's Chrome. --desktop remains an alias for --virtual-desktop.
+Use --virtual-desktop for Chrome in the Desktop panel.
+Run navigate --url <url> directly to open a page.
+The assistant-desktop feature flag and completed installation are required.
+The first browser command installs missing components, starts Chrome, and completes
+the requested action in one call. Allow up to 600 seconds for this command when
+using bash (timeout_seconds: 600). Opening the Desktop panel also starts
+the same installation and shows progress. No separate setup command is needed.
+Report other availability errors without switching to a personal computer.
+The assistant manages Chrome startup. Do not launch a separate desktop stack,
+install desktop packages, or drive webpages with shell-level xdotool.
+With --virtual-desktop, screenshot captures the page directly from Chrome over CDP
+as a color JPEG. Use --output to save it and file_read to view it. Do not use
+shell-level xwd or custom screenshot conversion scripts.
+Use snapshot for current element IDs and tabs list for current tab IDs.
+Refresh the snapshot after navigation, tab changes or stale-element errors.
+Inspect the result before retrying a failed action; it may have happened.
+A purple page pointer shows CDP mouse movement in the stream. Browser toolbar
+controls, native dialogs and other apps are outside this CLI's page controls.
+Do not combine --virtual-desktop with personal browser targets, other browser modes
+or --use-active-tab. Download waiting is unavailable on this target.
+Users can interact directly with the expanded desktop. If they ask you to pause,
+stop and wait. Take a fresh snapshot before resuming. Closing the viewer does not
+end automation. Run assistant browser --virtual-desktop detach when finished or
+blocked, including before asking a question. Chrome stays running.
 Each subcommand maps to a browser operation and communicates
 with the assistant process.
 
@@ -131,6 +172,8 @@ local. Useful for debugging or when deterministic backend selection
 is required.
 
 Examples:
+  $ assistant browser --virtual-desktop status
+  $ assistant browser --virtual-desktop screenshot --output /tmp/desktop-page.jpg
   $ assistant browser navigate --url https://example.com
   $ assistant browser snapshot
   $ assistant browser click --selector "#login"

package/src/cli/commands/browser.ts

@@ -28,6 +28,8 @@ import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { browserHelp, toKebab } from "./browser.help.js";
 
+const BROWSER_REQUEST_TIMEOUT_MS = 10 * 60_000;
+
 // ── Naming helpers ───────────────────────────────────────────────────
 
 /**
@@ -116,6 +118,7 @@ function attachOperationAction(
 
   subcmd.action(async (opts: Record<string, unknown>) => {
     const parentOpts = browser.opts() as {
+      desktop?: boolean;
       session?: string;
       json?: boolean;
       browserMode?: string;
@@ -130,6 +133,8 @@ function attachOperationAction(
     // targetClientId) and screenshot ergonomics (output).
     const input: Record<string, unknown> = {};
     const excludeKeys = new Set([
+      "desktop",
+      "virtualDesktop",
       "session",
       "json",
       "output",
@@ -163,9 +168,7 @@ function attachOperationAction(
       }
     }
 
-    // Browser operations can be long-running (page loads, auth
-    // challenges, downloads up to 120s, etc.), so use a generous
-    // IPC timeout that exceeds any server-side operation timeout.
+    // First use can include virtual desktop installation and Chrome startup.
     const ipcResult = await cliIpcCall<BrowserExecuteResult>(
       "browser_execute",
       {
@@ -173,10 +176,11 @@ function attachOperationAction(
           operation: meta.operation,
           input,
           sessionId,
+          ...(parentOpts.desktop ? { desktop: true } : {}),
           ...(conversationId ? { conversationId } : {}),
         },
       },
-      { timeoutMs: 180_000 },
+      { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
     );
 
     if (!ipcResult.ok) {
@@ -328,6 +332,22 @@ export function registerBrowserCommand(program: Command): void {
     description: browserHelp.description,
     build: (browser) => {
       applyCommandHelp(browser, browserHelp);
+      browser.hook("preAction", () => {
+        if (browser.opts().virtualDesktop) {
+          browser.setOptionValue("desktop", true);
+        }
+        const options = browser.opts();
+        if (
+          options.desktop &&
+          (options.targetClientId ||
+            (options.browserMode &&
+              !["auto", "cdp-inspect"].includes(options.browserMode)))
+        ) {
+          throw new Error(
+            "--virtual-desktop cannot be combined with a personal browser target or another browser mode",
+          );
+        }
+      });
 
       // Attach one action per browser operation
       for (const meta of BROWSER_OPERATION_META) {
@@ -339,6 +359,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "list").action(async (opts: { pretty?: boolean }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -364,11 +386,15 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "list",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {
@@ -409,6 +435,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "select").action(async (opts: { tabId: string }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -425,12 +453,16 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "select",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               tabId,
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {
@@ -456,6 +488,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "new").action(async (opts: { url?: string }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -475,12 +509,16 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "new",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               ...(opts.url ? { url: opts.url } : {}),
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {
@@ -512,6 +550,8 @@ export function registerBrowserCommand(program: Command): void {
 
       subcommand(tabs, "close").action(async (opts: { tabId: string }) => {
         const parentOpts = browser.opts() as {
+          desktop?: boolean;
+          browserMode?: string;
           session?: string;
           json?: boolean;
           targetClientId?: string;
@@ -532,12 +572,16 @@ export function registerBrowserCommand(program: Command): void {
             body: {
               command: "close",
               sessionId,
+              ...(parentOpts.desktop ? { desktop: true } : {}),
+              ...(parentOpts.browserMode
+                ? { browserMode: parentOpts.browserMode }
+                : {}),
               tabId,
               ...(conversationId ? { conversationId } : {}),
               ...(targetClientId ? { targetClientId } : {}),
             },
           },
-          { timeoutMs: 30_000 },
+          { timeoutMs: BROWSER_REQUEST_TIMEOUT_MS, cancelOnDisconnect: true },
         );
 
         if (!ipcResult.ok) {

package/src/cli/commands/plugins.ts

@@ -53,6 +53,7 @@ import {
   PluginAlreadyInStateException,
   PluginDirectoryNotFoundError,
 } from "../lib/toggle-plugin.js";
+import type { PluginUninstallWarningKey } from "../lib/uninstall-plugin.js";
 import type { PluginUpgradeResult } from "../lib/upgrade-plugin.js";
 import { getCliLogger } from "../logger.js";
 import { PLUGINS_SEARCH_INSTALL_HINT, pluginsHelp } from "./plugins.help.js";
@@ -666,11 +667,16 @@ export function registerPluginsCommand(program: Command): void {
             // when the daemon is unreachable (a transport error carries no
             // `statusCode`); an operator can still uninstall while it's stopped,
             // and `shutdown` then runs in this process, the only one available.
-            const daemon = await cliIpcCall<{ name: string; target: string }>(
-              "plugins_uninstall",
-              { pathParams: { name } },
-            );
-            let result: { name: string; target: string };
+            const daemon = await cliIpcCall<{
+              name: string;
+              target: string;
+              warnings?: PluginUninstallWarningKey[];
+            }>("plugins_uninstall", { pathParams: { name } });
+            let result: {
+              name: string;
+              target: string;
+              warnings?: PluginUninstallWarningKey[];
+            };
             if (daemon.ok && daemon.result) {
               result = daemon.result;
             } else if (daemon.statusCode === undefined) {
@@ -693,6 +699,11 @@ export function registerPluginsCommand(program: Command): void {
             console.log(
               `Uninstalled plugin "${result.name}" from ${result.target}`,
             );
+            for (const warning of result.warnings ?? []) {
+              console.warn(
+                `Warning: ${libs.uninstall.resolvePluginUninstallWarning(warning)}`,
+              );
+            }
           } catch (err) {
             if (err instanceof libs.installGitHub.InvalidPluginNameError) {
               console.error(err.message);

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

@@ -22,6 +22,8 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import { readPluginMcpServers } from "../../../plugins/mcp-servers.js";
+import { PluginManifestError } from "../../../util/plugin-manifest.js";
 import type { FetchLike } from "../fetch-like.js";
 import {
   type GitRunner,
@@ -1225,6 +1227,115 @@ describe("installPlugin — direct (untrusted) install", () => {
     expect(meta?.commit).toBe("a".repeat(40));
   });
 
+  test("installs a standard-only plugin without synthesizing package.json", async () => {
+    const fetch = makeContentsFetch({ tree: {} });
+    const runGit = fakeGitRunner({
+      tree: {
+        "plugin.json": JSON.stringify({
+          $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+          name: "standard-plugin",
+          version: "1.4.0",
+        }),
+        "mcp.json": JSON.stringify({
+          $schema: "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+          mcpServers: {
+            "standard-plugin": {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+            },
+          },
+        }),
+      },
+      commit: "9".repeat(40),
+    });
+
+    const result = await installPlugin(
+      {
+        name: "standard-plugin",
+        directSource: {
+          owner: "owner",
+          repo: "standard-plugin",
+          rootPath: "",
+          ref: "HEAD",
+        },
+      },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    expect(existsSync(join(result.target, "plugin.json"))).toBe(true);
+    expect(existsSync(join(result.target, "package.json"))).toBe(false);
+    expect(readInstallMeta(result.target)?.version).toBe("1.4.0");
+    const mcp = readPluginMcpServers({ workspacePluginsDir: pluginsDir });
+    expect(mcp.issues).toEqual([]);
+    expect(mcp.servers.map((server) => server.id)).toEqual(["standard-plugin"]);
+  });
+
+  test("synthesizes package.json beside a foreign plugin.json", async () => {
+    const fetch = makeContentsFetch({ tree: {} });
+    const runGit = fakeGitRunner({
+      tree: {
+        "plugin.json": JSON.stringify({ name: "foreign-plugin" }),
+        "mcp.json": JSON.stringify({
+          mcpServers: {
+            "foreign-plugin": {
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+            },
+          },
+        }),
+      },
+      commit: "8".repeat(40),
+    });
+
+    const result = await installPlugin(
+      {
+        name: "foreign-plugin",
+        directSource: {
+          owner: "owner",
+          repo: "foreign-plugin",
+          rootPath: "",
+          ref: "HEAD",
+        },
+      },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    expect(existsSync(join(result.target, "plugin.json"))).toBe(true);
+    expect(existsSync(join(result.target, "package.json"))).toBe(true);
+    const mcp = readPluginMcpServers({ workspacePluginsDir: pluginsDir });
+    expect(mcp.issues).toEqual([]);
+    expect(mcp.servers.map((server) => server.id)).toEqual(["foreign-plugin"]);
+  });
+
+  test("rejects a malformed claimed standard manifest before install", async () => {
+    const fetch = makeContentsFetch({ tree: {} });
+    const runGit = fakeGitRunner({
+      tree: {
+        "plugin.json": JSON.stringify({
+          $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+          name: "Invalid Standard Name",
+        }),
+      },
+      commit: "7".repeat(40),
+    });
+
+    await expect(
+      installPlugin(
+        {
+          name: "invalid-standard",
+          directSource: {
+            owner: "owner",
+            repo: "invalid-standard",
+            rootPath: "",
+            ref: "HEAD",
+          },
+        },
+        { fetch, runGit, workspacePluginsDir: pluginsDir },
+      ),
+    ).rejects.toBeInstanceOf(PluginManifestError);
+    expect(existsSync(join(pluginsDir, "invalid-standard"))).toBe(false);
+  });
+
   test("never overlays a curated adapter stub, even if one matches the name", async () => {
     // GIVEN a fetch that WOULD serve an adapter stub for the name, and a
     // postinstall runner that fails the test if it is ever invoked

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

@@ -14,6 +14,8 @@ import { join } from "node:path";
 import { gzipSync } from "node:zlib";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import { readPluginMcpServers } from "../../../plugins/mcp-servers.js";
+import { PluginManifestError } from "../../../util/plugin-manifest.js";
 import type { FetchLike } from "../fetch-like.js";
 import {
   PluginInstallDeclinedError,
@@ -145,7 +147,13 @@ const noSleep = async () => {};
 describe("installPluginFromPlatform — success", () => {
   test("downloads, verifies, and extracts files at the plugin root", async () => {
     const entries: TarEntry[] = [
-      { name: "plugin.json", content: '{"name":"reading-pal"}' },
+      {
+        name: "plugin.json",
+        content: JSON.stringify({
+          $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+          name: "reading-pal",
+        }),
+      },
       { name: "README.md", content: "# reading pal" },
       { name: "skills/read/SKILL.md", content: "skill body" },
     ];
@@ -177,7 +185,7 @@ describe("installPluginFromPlatform — success", () => {
     );
     expect(existsSync(join(target, "README.md"))).toBe(true);
     expect(existsSync(join(target, "skills", "read", "SKILL.md"))).toBe(true);
-    expect(existsSync(join(target, "package.json"))).toBe(true);
+    expect(existsSync(join(target, "package.json"))).toBe(false);
 
     // Provenance records the pinned commit and the verified ETag.
     const meta = readInstallMeta(target);
@@ -227,6 +235,73 @@ describe("installPluginFromPlatform — success", () => {
     expect(pkg.peerDependencies["@vellumai/plugin-api"]).toBeDefined();
   });
 
+  test("synthesizes package.json beside a foreign plugin.json", async () => {
+    const fetchFn = makeInstallFetch({
+      entries: [
+        {
+          name: "plugin.json",
+          content: JSON.stringify({ name: "foreign-plugin" }),
+        },
+        {
+          name: "mcp.json",
+          content: JSON.stringify({
+            mcpServers: {
+              "foreign-plugin": {
+                type: "streamable-http",
+                url: "https://mcp.example.com",
+              },
+            },
+          }),
+        },
+      ],
+      ref: "d".repeat(40),
+      repo: "example-org/foreign-plugin",
+    });
+
+    const result = await installPluginFromPlatform(
+      { name: "foreign-plugin" },
+      {
+        fetch: fetchFn,
+        platformBaseUrl: PLATFORM,
+        workspacePluginsDir: pluginsDir,
+      },
+    );
+
+    expect(existsSync(join(result.target, "plugin.json"))).toBe(true);
+    expect(existsSync(join(result.target, "package.json"))).toBe(true);
+    const mcp = readPluginMcpServers({ workspacePluginsDir: pluginsDir });
+    expect(mcp.issues).toEqual([]);
+    expect(mcp.servers.map((server) => server.id)).toEqual(["foreign-plugin"]);
+  });
+
+  test("rejects a malformed claimed standard manifest before install", async () => {
+    const fetchFn = makeInstallFetch({
+      entries: [
+        {
+          name: "plugin.json",
+          content: JSON.stringify({
+            $schema:
+              "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+          }),
+        },
+      ],
+      ref: "e".repeat(40),
+      repo: "example-org/invalid-standard",
+    });
+
+    await expect(
+      installPluginFromPlatform(
+        { name: "invalid-standard" },
+        {
+          fetch: fetchFn,
+          platformBaseUrl: PLATFORM,
+          workspacePluginsDir: pluginsDir,
+        },
+      ),
+    ).rejects.toBeInstanceOf(PluginManifestError);
+    expect(existsSync(join(pluginsDir, "invalid-standard"))).toBe(false);
+  });
+
   test("leaves an upstream package.json in place", async () => {
     const fetchFn = makeInstallFetch({
       entries: [

package/src/cli/lib/__tests__/list-installed-plugins.test.ts

@@ -93,6 +93,46 @@ describe("listInstalledPlugins", () => {
     expect(result[0]!.packageJson?.icon).toBe("🚀");
   });
 
+  test("lists metadata from a standard-only plugin.json", () => {
+    mkdirSync(join(pluginsDir, "standard"));
+    writeFileSync(
+      join(pluginsDir, "standard", "plugin.json"),
+      JSON.stringify({
+        $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+        name: "standard",
+        version: "3.0.0",
+        description: "standard plugin",
+      }),
+    );
+
+    const result = listInstalledPlugins({ workspacePluginsDir: pluginsDir });
+
+    expect(result[0]!.packageJson).toEqual({
+      name: "standard",
+      version: "3.0.0",
+      description: "standard plugin",
+      peerDependencies: undefined,
+    });
+    expect(result[0]!.issues).toEqual([]);
+  });
+
+  test("does not validate an unselected plugin.json beside package.json", () => {
+    mkdirSync(join(pluginsDir, "legacy"));
+    writeFileSync(
+      join(pluginsDir, "legacy", "package.json"),
+      JSON.stringify({ name: "legacy", version: "1.0.0" }),
+    );
+    writeFileSync(
+      join(pluginsDir, "legacy", "plugin.json"),
+      "{ foreign and malformed }",
+    );
+
+    const result = listInstalledPlugins({ workspacePluginsDir: pluginsDir });
+
+    expect(result[0]!.packageJson?.version).toBe("1.0.0");
+    expect(result[0]!.issues).toEqual([]);
+  });
+
   test.each([
     ["missing vellum block", { name: "p", version: "1.0.0" }],
     ["non-string icon", { name: "p", version: "1.0.0", vellum: { icon: 42 } }],
@@ -120,7 +160,9 @@ describe("listInstalledPlugins", () => {
     const result = listInstalledPlugins({ workspacePluginsDir: pluginsDir });
     expect(result).toHaveLength(1);
     expect(result[0]!.packageJson).toBeNull();
-    expect(result[0]!.issues).toEqual(["missing package.json"]);
+    expect(result[0]!.issues[0]).toContain(
+      "missing package.json and plugin.json",
+    );
   });
 
   test("reports malformed JSON as an issue rather than failing", () => {
@@ -130,7 +172,7 @@ describe("listInstalledPlugins", () => {
     const result = listInstalledPlugins({ workspacePluginsDir: pluginsDir });
     expect(result).toHaveLength(1);
     expect(result[0]!.packageJson).toBeNull();
-    expect(result[0]!.issues[0]).toMatch(/invalid JSON/);
+    expect(result[0]!.issues[0]).toContain("could not be read or parsed");
   });
 
   test("reports non-object package.json as an issue", () => {
@@ -143,7 +185,7 @@ describe("listInstalledPlugins", () => {
     const result = listInstalledPlugins({ workspacePluginsDir: pluginsDir });
     expect(result).toHaveLength(1);
     expect(result[0]!.packageJson).toBeNull();
-    expect(result[0]!.issues).toContain("package.json is not an object");
+    expect(result[0]!.issues[0]).toContain("failed schema validation");
   });
 
   test("skips hidden entries and non-directories", () => {