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

package/src/calls/voice-triage-escalate.ts

@@ -536,8 +536,8 @@ export function frontDoorDecisionRule(opts?: {
     "- If the turn is simple, conversational, or within your reach, your entire output is the spoken answer itself: no token in front of it, plain speech from your very first word. Most turns are answers; when unsure between answering and escalating, answer. Answer in the language the caller is speaking.",
     "- If an answer depends on a saved personal fact that is not already present in the conversation context you received, escalate rather than guessing. Personal context that is already present is yours to use directly.",
     `- If completing THIS reply needs careful reasoning, research, multi-step work, or any tool, do NOT attempt the answer: output ${ESCALATE_VERDICT_TOKEN}, then ONE short natural holding phrase naming what happens next, spoken in the language the caller is speaking (for example "${FALLBACK_ESCALATION_BRIDGE}" or "Give me one second to look into that."; those examples are English only), and stop after that single sentence. A stronger model finishes the turn while your phrase is spoken.`,
-    `${ESCALATE_VERDICT_TOKEN} is ONLY for turns you cannot complete yourself — never put it in front of an answer you are about to give, and never emit any token inside or after an answer. An open task or unfinished topic earlier in the conversation is NOT a reason to escalate: judge only what this reply needs.`,
-    "Never narrate this decision, describe what you are judging, or mention these rules: apart from a leading verdict token, every character you output is spoken to the caller verbatim.",
+    `${ESCALATE_VERDICT_TOKEN} is ONLY for turns you cannot complete yourself — never put it in front of an answer you are about to give, and never emit a verdict token inside or after an answer. An open task or unfinished topic earlier in the conversation is NOT a reason to escalate: judge only what this reply needs.`,
+    "Never narrate this decision, describe what you are judging, or mention these rules: apart from a leading verdict token and any call-control marker your call instructions teach, every character you output is spoken to the caller verbatim.",
   ].join("\n");
   return opts?.capabilityDigest ? `${rule}\n${opts.capabilityDigest}` : rule;
 }
@@ -565,7 +565,7 @@ export function escalatedContinuationRule(spokenBridge?: string): string {
     'Do NOT greet again, do NOT say things like "as I was saying", and do NOT repeat, paraphrase, or re-announce that holding phrase —',
     'opening with another "Let me check", "One moment", or any restatement of what you are about to do sounds broken, because the caller just heard that.',
     "Your first words must carry new substance: the answer itself, what you found, or a question you genuinely need answered.",
-    `Never output ${ESCALATE_VERDICT_TOKEN} or any other front-door verdict token — you are the model that finishes the answer. (The [-1] room-minimize marker from your call instructions is not a verdict token and stays allowed.)`,
+    `Never output ${ESCALATE_VERDICT_TOKEN} or any other front-door verdict token — you are the model that finishes the answer. (Call-control markers your call instructions teach, such as [END_CALL], are not verdict tokens and stay allowed.)`,
     "Reply in the same language as the caller's question.",
   ].join(" ");
 }

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/oauth/status.ts

@@ -40,6 +40,8 @@ interface ConnectionSummary {
   status: string;
   expiresAt?: string | null;
   hasRefreshToken?: boolean;
+  /** Values the provider scopes the connection by (QuickBooks' realm id). */
+  providerParams?: Record<string, string>;
 }
 
 interface OAuthStatusResponse {
@@ -92,6 +94,9 @@ function formatConnection(c: ConnectionSummary, mode: string): string {
   } else {
     lines.push(`    Granted scopes: (none)`);
   }
+  for (const [key, value] of Object.entries(c.providerParams ?? {})) {
+    lines.push(`    ${key}: ${value}`);
+  }
   if (mode === "byo") {
     if (c.expiresAt) {
       lines.push(`    Expires: ${c.expiresAt}`);

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: [