@stigmer/cli 3.15.3-dev.20260914100347 → 3.15.3-dev.20260916211208

package/src/resources/get-bindings.ts

@@ -10,6 +10,7 @@ import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentins
 import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
 import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import { PluginSchema } from "@stigmer/protos/ai/stigmer/agentic/plugin/v1/api_pb";
 import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
 import { SkillSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
 import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
@@ -26,24 +27,87 @@ export interface ResourceResult {
   readonly message: Message;
 }
 
-type Getter = (client: Stigmer, ref: ParsedReference) => Promise<ResourceResult>;
+type Getter = (
+  client: Stigmer,
+  ref: ParsedReference,
+) => Promise<ResourceResult>;
 
 // Every kind declaring Get in the verb matrix must have an entry here (or a
 // documented special case, e.g. organization) — the conformance test in
 // registry/registry.test.ts enforces it, so the two cannot drift.
 export const GET_BINDINGS: ReadonlyMap<ApiResourceKind, Getter> = new Map([
-  [ApiResourceKind.agent, refGetter(ApiResourceKind.agent, AgentSchema, (c) => c.agent)],
-  [ApiResourceKind.agent_instance, refGetter(ApiResourceKind.agent_instance, AgentInstanceSchema, (c) => c.agentInstance)],
-  [ApiResourceKind.workflow, refGetter(ApiResourceKind.workflow, WorkflowSchema, (c) => c.workflow)],
-  [ApiResourceKind.workflow_instance, refGetter(ApiResourceKind.workflow_instance, WorkflowInstanceSchema, (c) => c.workflowInstance)],
-  [ApiResourceKind.mcp_server, refGetter(ApiResourceKind.mcp_server, McpServerSchema, (c) => c.mcpServer)],
-  [ApiResourceKind.project, refGetter(ApiResourceKind.project, ProjectSchema, (c) => c.project)],
-  [ApiResourceKind.environment, refGetter(ApiResourceKind.environment, EnvironmentSchema, (c) => c.environment)],
-  [ApiResourceKind.agent_channel, refGetter(ApiResourceKind.agent_channel, AgentChannelSchema, (c) => c.agentChannel)],
-  [ApiResourceKind.channel_app, refGetter(ApiResourceKind.channel_app, ChannelAppSchema, (c) => c.channelapp)],
-  [ApiResourceKind.schedule, refGetter(ApiResourceKind.schedule, ScheduleSchema, (c) => c.schedule)],
-  [ApiResourceKind.skill, refGetter(ApiResourceKind.skill, SkillSchema, (c) => c.skill)],
-  [ApiResourceKind.api_key, idOnlyGetter(ApiKeySchema, (c) => c.apiKey, "API keys")],
+  [
+    ApiResourceKind.agent,
+    refGetter(ApiResourceKind.agent, AgentSchema, (c) => c.agent),
+  ],
+  [
+    ApiResourceKind.agent_instance,
+    refGetter(
+      ApiResourceKind.agent_instance,
+      AgentInstanceSchema,
+      (c) => c.agentInstance,
+    ),
+  ],
+  [
+    ApiResourceKind.workflow,
+    refGetter(ApiResourceKind.workflow, WorkflowSchema, (c) => c.workflow),
+  ],
+  [
+    ApiResourceKind.workflow_instance,
+    refGetter(
+      ApiResourceKind.workflow_instance,
+      WorkflowInstanceSchema,
+      (c) => c.workflowInstance,
+    ),
+  ],
+  [
+    ApiResourceKind.mcp_server,
+    refGetter(ApiResourceKind.mcp_server, McpServerSchema, (c) => c.mcpServer),
+  ],
+  [
+    ApiResourceKind.project,
+    refGetter(ApiResourceKind.project, ProjectSchema, (c) => c.project),
+  ],
+  [
+    ApiResourceKind.environment,
+    refGetter(
+      ApiResourceKind.environment,
+      EnvironmentSchema,
+      (c) => c.environment,
+    ),
+  ],
+  [
+    ApiResourceKind.agent_channel,
+    refGetter(
+      ApiResourceKind.agent_channel,
+      AgentChannelSchema,
+      (c) => c.agentChannel,
+    ),
+  ],
+  [
+    ApiResourceKind.channel_app,
+    refGetter(
+      ApiResourceKind.channel_app,
+      ChannelAppSchema,
+      (c) => c.channelapp,
+    ),
+  ],
+  [
+    ApiResourceKind.schedule,
+    refGetter(ApiResourceKind.schedule, ScheduleSchema, (c) => c.schedule),
+  ],
+  [
+    ApiResourceKind.skill,
+    refGetter(ApiResourceKind.skill, SkillSchema, (c) => c.skill),
+  ],
+  [
+    ApiResourceKind.plugin,
+    refGetter(ApiResourceKind.plugin, PluginSchema, (c) => c.plugin),
+  ],
+  [
+    ApiResourceKind.api_key,
+    idOnlyGetter(ApiKeySchema, (c) => c.apiKey, "API keys"),
+  ],
 ]);
 
 export function getterFor(kind: ApiResourceKind): Getter | undefined {
@@ -53,20 +117,34 @@ export function getterFor(kind: ApiResourceKind): Getter | undefined {
 // A resource fetchable by ID or by org/slug reference.
 interface RefClient {
   get(id: string): Promise<Message>;
-  getByReference(ref: { org: string; slug: string; kind: number }): Promise<Message>;
+  getByReference(ref: {
+    org: string;
+    slug: string;
+    kind: number;
+  }): Promise<Message>;
 }
 
-function refGetter(kind: ApiResourceKind, schema: DescMessage, pick: (c: Stigmer) => RefClient): Getter {
+function refGetter(
+  kind: ApiResourceKind,
+  schema: DescMessage,
+  pick: (c: Stigmer) => RefClient,
+): Getter {
   return async (client, ref) => {
     const sub = pick(client);
     const message =
-      ref.kind === "id" ? await sub.get(ref.id) : await sub.getByReference({ org: ref.org, slug: ref.slug, kind });
+      ref.kind === "id"
+        ? await sub.get(ref.id)
+        : await sub.getByReference({ org: ref.org, slug: ref.slug, kind });
     return { schema, message };
   };
 }
 
 // A resource fetchable only by ID (e.g. API keys are not slug-addressable).
-function idOnlyGetter(schema: DescMessage, pick: (c: Stigmer) => { get(id: string): Promise<Message> }, label: string): Getter {
+function idOnlyGetter(
+  schema: DescMessage,
+  pick: (c: Stigmer) => { get(id: string): Promise<Message> },
+  label: string,
+): Getter {
   return async (client, ref) => {
     if (ref.kind !== "id") {
       throw new UsageError(`${label} can only be fetched by ID`);

package/src/resources/list.ts

@@ -35,7 +35,14 @@ import { OrganizationSchema } from "@stigmer/protos/ai/stigmer/tenancy/organizat
 import type { Stigmer } from "@stigmer/sdk";
 import { UsageError } from "../errors/index.js";
 import type { OutputFormat } from "../output/index.js";
-import { bool, type JsonObject, obj, renderCollection, str, type TableShape } from "./render.js";
+import {
+  bool,
+  type JsonObject,
+  obj,
+  renderCollection,
+  str,
+  type TableShape,
+} from "./render.js";
 
 // Kinds that list through the SearchService (list mode: empty query, org
 // scope). Must stay in step with the server's SearchableKinds allowlist
@@ -43,14 +50,16 @@ import { bool, type JsonObject, obj, renderCollection, str, type TableShape } fr
 // search_criteria.go): a kind present here but absent there silently lists
 // as empty. The LIST_HANDLERS kinds are deliberately NOT here — see the
 // header: not search-indexed, or better served by their dedicated RPC.
-export const SEARCH_KINDS: ReadonlySet<ApiResourceKind> = new Set<ApiResourceKind>([
-  ApiResourceKind.agent,
-  ApiResourceKind.workflow,
-  ApiResourceKind.mcp_server,
-  ApiResourceKind.project,
-  ApiResourceKind.skill,
-  ApiResourceKind.environment,
-]);
+export const SEARCH_KINDS: ReadonlySet<ApiResourceKind> =
+  new Set<ApiResourceKind>([
+    ApiResourceKind.agent,
+    ApiResourceKind.workflow,
+    ApiResourceKind.mcp_server,
+    ApiResourceKind.project,
+    ApiResourceKind.skill,
+    ApiResourceKind.plugin,
+    ApiResourceKind.environment,
+  ]);
 
 // One fetched page of a listing: what to render (entries + schema) and how
 // (table). Rendering and --limit truncation happen centrally in
@@ -64,12 +73,19 @@ interface ListPage {
 // Where the RPC paginates, the handler still forwards `limit` as the page
 // size so the server does the bounding; the dispatcher's slice is then a
 // no-op. Where it doesn't, the slice IS the bound.
-type ListFn = (client: Stigmer, org: string, limit: number) => Promise<ListPage>;
+type ListFn = (
+  client: Stigmer,
+  org: string,
+  limit: number,
+) => Promise<ListPage>;
 
 // Dedicated-RPC list handlers for the non-search-indexed kinds. Every kind
 // declaring List in the verb matrix must appear here or in SEARCH_KINDS —
 // the conformance test enforces it, so the two cannot drift.
-export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiResourceKind, ListFn>([
+export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<
+  ApiResourceKind,
+  ListFn
+>([
   [
     ApiResourceKind.organization,
     async (client) => {
@@ -77,7 +93,11 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
       // a caller's org set is small by nature). The paginated `find` RPC is
       // platform-admin-only — the wrong surface for `list organization`.
       const result = await client.organization.findMyOrganizations();
-      return { schema: OrganizationSchema, entries: result.entries, table: ORG_TABLE };
+      return {
+        schema: OrganizationSchema,
+        entries: result.entries,
+        table: ORG_TABLE,
+      };
     },
   ],
   [
@@ -85,25 +105,43 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
     async (client) => {
       // findAll is caller-scoped and unpaginated (Empty request).
       const result = await client.apiKey.findAll();
-      return { schema: ApiKeySchema, entries: result.entries, table: APIKEY_TABLE };
+      return {
+        schema: ApiKeySchema,
+        entries: result.entries,
+        table: APIKEY_TABLE,
+      };
     },
   ],
   [
     ApiResourceKind.agent_instance,
     async (client, org, limit) => {
       const result = await client.agentInstance.list(
-        create(ListAgentInstancesRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
+        create(ListAgentInstancesRequestSchema, {
+          org,
+          pageInfo: create(PageInfoSchema, { num: 1, size: limit }),
+        }),
       );
-      return { schema: AgentInstanceSchema, entries: result.items, table: INSTANCE_TABLE };
+      return {
+        schema: AgentInstanceSchema,
+        entries: result.items,
+        table: INSTANCE_TABLE,
+      };
     },
   ],
   [
     ApiResourceKind.agent_channel,
     async (client, org, limit) => {
       const result = await client.agentChannel.list(
-        create(ListAgentChannelsRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
+        create(ListAgentChannelsRequestSchema, {
+          org,
+          pageInfo: create(PageInfoSchema, { num: 1, size: limit }),
+        }),
       );
-      return { schema: AgentChannelSchema, entries: result.items, table: AGENT_CHANNEL_TABLE };
+      return {
+        schema: AgentChannelSchema,
+        entries: result.items,
+        table: AGENT_CHANNEL_TABLE,
+      };
     },
   ],
   [
@@ -112,8 +150,14 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
       // listByOrg has no pagination on its contract (the per-org set is small
       // by design); the dispatcher's slice bounds the output.
       // `channelapp` (not `channelApp`) is a recorded SDK codegen naming quirk.
-      const result = await client.channelapp.listByOrg(create(ListChannelAppsByOrgInputSchema, { org }));
-      return { schema: ChannelAppSchema, entries: result.entries, table: CHANNEL_APP_TABLE };
+      const result = await client.channelapp.listByOrg(
+        create(ListChannelAppsByOrgInputSchema, { org }),
+      );
+      return {
+        schema: ChannelAppSchema,
+        entries: result.entries,
+        table: CHANNEL_APP_TABLE,
+      };
     },
   ],
   [
@@ -128,9 +172,16 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
         );
       }
       const result = await client.schedule.list(
-        create(ListSchedulesRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
+        create(ListSchedulesRequestSchema, {
+          org,
+          pageInfo: create(PageInfoSchema, { num: 1, size: limit }),
+        }),
       );
-      return { schema: ScheduleSchema, entries: result.items, table: SCHEDULE_TABLE };
+      return {
+        schema: ScheduleSchema,
+        entries: result.items,
+        table: SCHEDULE_TABLE,
+      };
     },
   ],
   [
@@ -142,8 +193,14 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
       // api_key above — the agent_instance precedent, not an oversight.
       // Promoted from a bespoke pre-gate route in commands/list.ts by
       // stigmer/stigmer#469 (it had shipped working-but-unadvertised).
-      const result = await client.session.list(create(ListSessionsRequestSchema, { pageSize: limit }));
-      return { schema: SessionSchema, entries: result.entries, table: SESSION_TABLE };
+      const result = await client.session.list(
+        create(ListSessionsRequestSchema, { pageSize: limit }),
+      );
+      return {
+        schema: SessionSchema,
+        entries: result.entries,
+        table: SESSION_TABLE,
+      };
     },
   ],
 ]);
@@ -162,7 +219,12 @@ export async function listResources(
   // rather than per-handler is what keeps the flag honest for every kind —
   // organization and api_key shipped ignoring it when handlers owned this
   // (stigmer/stigmer#312).
-  return renderCollection(page.schema, page.entries.slice(0, limit), format, page.table);
+  return renderCollection(
+    page.schema,
+    page.entries.slice(0, limit),
+    format,
+    page.table,
+  );
 }
 
 async function fetchListPage(
@@ -178,8 +240,16 @@ async function fetchListPage(
   if (!SEARCH_KINDS.has(kind)) {
     throw new UsageError("list is not implemented for this resource type");
   }
-  const result = await client.search.query({ kinds: [kind], org, page: { num: 1, size: limit } });
-  return { schema: SearchResultSchema, entries: result.entries, table: SEARCH_TABLE };
+  const result = await client.search.query({
+    kinds: [kind],
+    org,
+    page: { num: 1, size: limit },
+  });
+  return {
+    schema: SearchResultSchema,
+    entries: result.entries,
+    table: SEARCH_TABLE,
+  };
 }
 
 // Shared with `search` — both render SearchService results identically.
@@ -258,7 +328,9 @@ const CHANNEL_APP_TABLE: TableShape = {
       str(metadata, "id"),
       str(metadata, "slug"),
       providerOf(obj(json, "spec")),
-      date(str(obj(obj(obj(json, "status"), "audit"), "spec_audit"), "created_at")),
+      date(
+        str(obj(obj(obj(json, "status"), "audit"), "spec_audit"), "created_at"),
+      ),
     ];
   },
 };
@@ -332,7 +404,9 @@ function apiKeyExpiry(spec: JsonObject): string {
 
 function truncate(text: string, max: number): string {
   const normalized = text.replace(/\s+/g, " ").trim();
-  return normalized.length > max ? `${normalized.slice(0, max - 1)}…` : normalized;
+  return normalized.length > max
+    ? `${normalized.slice(0, max - 1)}…`
+    : normalized;
 }
 
 function date(timestamp: string): string {

package/src/resources/plugin.test.ts

@@ -0,0 +1,233 @@
+// Pins the plugin directory walker: detection by any of the four manifests,
+// sorted sized entries, the ignore matcher applied (defaults, .gitignore,
+// .stigmerignore), symlinks never followed, and the JSON projection that
+// reduces overlay documents to their paths.
+
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { readPluginPackage } from "@stigmer/plugin-package";
+import {
+  describePlugin,
+  isPluginDirectory,
+  readPluginDirectory,
+} from "./plugin.js";
+
+let root: string;
+
+function write(rel: string, content: string): void {
+  const full = join(root, rel);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+beforeAll(() => {
+  root = mkdtempSync(join(tmpdir(), "stigmer-plugin-walk-"));
+  write(
+    ".cursor-plugin/plugin.json",
+    JSON.stringify({
+      name: "walker",
+      skills: "./skills/",
+      mcpServers: "./mcp.json",
+      variables: {
+        type: "object",
+        properties: { TOKEN: { type: "string" } },
+        required: ["TOKEN"],
+      },
+    }),
+  );
+  write(
+    "mcp.json",
+    JSON.stringify({
+      mcpServers: {
+        api: {
+          type: "http",
+          url: "https://api.example.com/mcp",
+          headers: { Authorization: "Bearer ${TOKEN}" },
+        },
+      },
+    }),
+  );
+  write(
+    "skills/greet/SKILL.md",
+    "---\nname: greet\ndescription: Says hello.\n---\nSay hello.\n",
+  );
+  write("skills/greet/scripts/hello.sh", "echo hello");
+  write("skills/greet/secrets.yaml", "never: included");
+  write("skills/greet/.env", "SECRET=1");
+  write("node_modules/dep/index.js", "module.exports = 1");
+  write("ai.stigmer/agent.yaml", "kind: Agent\n");
+  write(".gitignore", "*.log\n");
+  write("debug.log", "ignored by .gitignore");
+  write(".stigmerignore", "drafts/\n");
+  write("drafts/idea.md", "ignored by .stigmerignore");
+  symlinkSync(join(root, "mcp.json"), join(root, "mcp-link.json"));
+});
+
+afterAll(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("isPluginDirectory", () => {
+  it("is true for a directory holding any of the four manifests and false otherwise", () => {
+    expect(isPluginDirectory(root)).toBe(true);
+    expect(isPluginDirectory(join(root, "skills"))).toBe(false);
+    expect(isPluginDirectory(join(root, "mcp.json"))).toBe(false);
+    expect(isPluginDirectory(join(root, "does-not-exist"))).toBe(false);
+  });
+});
+
+describe("readPluginDirectory", () => {
+  it("lists sorted, sized, contained entries and applies every ignore source", () => {
+    const { files, stats } = readPluginDirectory(root);
+    expect(files.entries.map((e) => e.path)).toEqual([
+      ".cursor-plugin/plugin.json",
+      ".gitignore",
+      ".stigmerignore",
+      "ai.stigmer/agent.yaml",
+      "mcp.json",
+      "skills/greet/SKILL.md",
+      "skills/greet/scripts/hello.sh",
+    ]);
+    expect(
+      files.entries.find((e) => e.path === "skills/greet/scripts/hello.sh")
+        ?.size,
+    ).toBe("echo hello".length);
+    // .env and secrets.yaml (security defaults), debug.log (.gitignore); the
+    // symlink is neither a file nor a directory and is skipped uncounted.
+    expect(stats).toMatchObject({
+      filesIncluded: 7,
+      filesIgnored: 3,
+      dirsSkipped: 2,
+    });
+  });
+
+  it("reads exactly the listed bytes", () => {
+    const { files } = readPluginDirectory(root);
+    expect(new TextDecoder().decode(files.read("ai.stigmer/agent.yaml"))).toBe(
+      "kind: Agent\n",
+    );
+  });
+
+  it("feeds the reader a plugin it accepts", () => {
+    const { files, stats } = readPluginDirectory(root);
+    const outcome = readPluginPackage(files);
+    expect(outcome.ok).toBe(true);
+    if (!outcome.ok) return;
+    const description = describePlugin(outcome.plugin, outcome.warnings, stats);
+    expect(description.plugin.overlay).toEqual({
+      agent: "ai.stigmer/agent.yaml",
+      workflows: [],
+      mcpServers: [],
+    });
+    expect(description.excludedFiles).toBe(3);
+    expect(JSON.stringify(description)).not.toContain("bytes");
+  });
+});
+
+describe("zipPluginFiles", () => {
+  it("writes the walked list deterministically and round-trips through the library's own reader", async () => {
+    const { zipPluginFiles } = await import("./plugin.js");
+    const { unzipSync } = await import("fflate");
+    const directory = readPluginDirectory(root);
+    const first = zipPluginFiles(directory.files);
+    const second = zipPluginFiles(directory.files);
+    expect(Buffer.from(first).equals(Buffer.from(second))).toBe(true);
+    const entries = Object.keys(unzipSync(first)).sort();
+    expect(entries).toEqual(directory.files.entries.map((e) => e.path));
+    expect(entries).not.toContain("debug.log");
+    expect(entries).not.toContain("mcp-link.json");
+  });
+});
+
+describe("renderPushOutcome", () => {
+  it("summarises the install by kind, lists members and carries warnings", async () => {
+    const { renderPushOutcome } = await import("./plugin.js");
+    const { create } = await import("@bufbuild/protobuf");
+    const { PluginSchema } =
+      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/api_pb");
+    const { PluginMemberSchema } =
+      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/io_pb");
+    const { PluginDialect } =
+      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/spec_pb");
+    const { PluginState } =
+      await import("@stigmer/protos/ai/stigmer/agentic/plugin/v1/status_pb");
+    const { ApiResourceKind } =
+      await import("@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb");
+    const { renderResult } = await import("../output/command-result.js");
+
+    const plugin = create(PluginSchema, {
+      metadata: { id: "plg_1", slug: "thermos" },
+      spec: {
+        name: "thermos",
+        version: "1.2.0",
+        dialect: PluginDialect.CURSOR,
+      },
+      status: {
+        digest: "a".repeat(64),
+        state: PluginState.READY,
+        materialized: { skills: 2, mcpServers: 1, agents: 1, workflows: 0 },
+        warnings: [
+          {
+            kind: "model-hint-unresolved",
+            message:
+              "sub-agent 'reviewer' names model 'sonnet'; it runs on the session's model",
+          },
+        ],
+      },
+    });
+    const members = [
+      create(PluginMemberSchema, {
+        kind: ApiResourceKind.skill,
+        id: "skl_1",
+        slug: "review",
+        name: "review",
+      }),
+      create(PluginMemberSchema, {
+        kind: ApiResourceKind.skill,
+        id: "skl_2",
+        slug: "triage",
+        name: "triage",
+      }),
+      create(PluginMemberSchema, {
+        kind: ApiResourceKind.mcp_server,
+        id: "mcp_1",
+        slug: "github",
+        name: "github",
+      }),
+      create(PluginMemberSchema, {
+        kind: ApiResourceKind.agent,
+        id: "agt_1",
+        slug: "thermos",
+        name: "thermos",
+      }),
+    ];
+    const result = renderPushOutcome({ plugin, members, archiveBytes: 2048 });
+    const lines: string[] = [];
+    const original = process.stderr.write.bind(process.stderr);
+    process.stderr.write = ((chunk: string | Uint8Array) => {
+      lines.push(String(chunk));
+      return true;
+    }) as typeof process.stderr.write;
+    try {
+      renderResult(result, "human");
+    } finally {
+      process.stderr.write = original;
+    }
+    const text = lines.join("");
+    expect(text).toContain(
+      "Installed plugin 'thermos' (2 skills, 1 MCP server, 1 agent) with 1 warning",
+    );
+    expect(text).toContain("Skills");
+    expect(text).toContain("review, triage");
+    expect(text).toContain("Cursor plugin");
+    expect(text).toContain("runs on the session's model");
+  });
+});