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

package/src/registry/registry.test.ts

@@ -49,7 +49,9 @@ describe("registry — alias resolution", () => {
   });
 
   it("resolution is case-insensitive", () => {
-    expect(registry.getByAlias("MCP-SERVER")?.kind).toBe(ApiResourceKind.mcp_server);
+    expect(registry.getByAlias("MCP-SERVER")?.kind).toBe(
+      ApiResourceKind.mcp_server,
+    );
   });
 
   it("returns undefined for an unknown alias", () => {
@@ -61,7 +63,10 @@ describe("registry — alias resolution", () => {
   // row in `list types` that the pre-gate route then shadows — the
   // stigmer/stigmer#469 class (see the alias-shadowing suite below).
   it("does not register the runtime execution kinds as addressable types", () => {
-    for (const kind of [ApiResourceKind.agent_execution, ApiResourceKind.workflow_execution]) {
+    for (const kind of [
+      ApiResourceKind.agent_execution,
+      ApiResourceKind.workflow_execution,
+    ]) {
       expect(registry.getByKind(kind)).toBeUndefined();
     }
   });
@@ -69,14 +74,26 @@ describe("registry — alias resolution", () => {
 
 describe("registry — YAML kind resolution", () => {
   it("resolves the exact YAML kind", () => {
-    expect(registry.getByYamlKind("McpServer")?.kind).toBe(ApiResourceKind.mcp_server);
-    expect(registry.getByYamlKind("Workflow")?.kind).toBe(ApiResourceKind.workflow);
+    expect(registry.getByYamlKind("McpServer")?.kind).toBe(
+      ApiResourceKind.mcp_server,
+    );
+    expect(registry.getByYamlKind("Workflow")?.kind).toBe(
+      ApiResourceKind.workflow,
+    );
   });
 });
 
 describe("registry — verb support matrix", () => {
   it("agent supports read + run + search verbs", () => {
-    for (const v of [Verb.Apply, Verb.Validate, Verb.Get, Verb.List, Verb.Delete, Verb.Run, Verb.Search]) {
+    for (const v of [
+      Verb.Apply,
+      Verb.Validate,
+      Verb.Get,
+      Verb.List,
+      Verb.Delete,
+      Verb.Run,
+      Verb.Search,
+    ]) {
       expect(registry.supportsVerb(ApiResourceKind.agent, v)).toBe(true);
     }
     expect(registry.supportsVerb(ApiResourceKind.agent, Verb.Push)).toBe(false);
@@ -84,21 +101,33 @@ describe("registry — verb support matrix", () => {
 
   it("skill supports push but not apply", () => {
     expect(registry.supportsVerb(ApiResourceKind.skill, Verb.Push)).toBe(true);
-    expect(registry.supportsVerb(ApiResourceKind.skill, Verb.Apply)).toBe(false);
+    expect(registry.supportsVerb(ApiResourceKind.skill, Verb.Apply)).toBe(
+      false,
+    );
   });
 
   it("workflow_instance has no list verb", () => {
-    expect(registry.supportsVerb(ApiResourceKind.workflow_instance, Verb.Get)).toBe(true);
-    expect(registry.supportsVerb(ApiResourceKind.workflow_instance, Verb.List)).toBe(false);
+    expect(
+      registry.supportsVerb(ApiResourceKind.workflow_instance, Verb.Get),
+    ).toBe(true);
+    expect(
+      registry.supportsVerb(ApiResourceKind.workflow_instance, Verb.List),
+    ).toBe(false);
   });
 
   it("agent_channel supports the full declarative verb set", () => {
     for (const v of [Verb.Apply, Verb.Get, Verb.List, Verb.Delete]) {
-      expect(registry.supportsVerb(ApiResourceKind.agent_channel, v)).toBe(true);
+      expect(registry.supportsVerb(ApiResourceKind.agent_channel, v)).toBe(
+        true,
+      );
     }
     // The install flow is console-driven and cloud-only — never a CLI verb.
-    expect(registry.supportsVerb(ApiResourceKind.agent_channel, Verb.Run)).toBe(false);
-    expect(registry.supportsVerb(ApiResourceKind.agent_channel, Verb.Search)).toBe(false);
+    expect(registry.supportsVerb(ApiResourceKind.agent_channel, Verb.Run)).toBe(
+      false,
+    );
+    expect(
+      registry.supportsVerb(ApiResourceKind.agent_channel, Verb.Search),
+    ).toBe(false);
   });
 
   it("schedule supports the full declarative verb set", () => {
@@ -106,19 +135,27 @@ describe("registry — verb support matrix", () => {
       expect(registry.supportsVerb(ApiResourceKind.schedule, v)).toBe(true);
     }
     // Firing rides `stigmer schedule trigger`, never the generic run verb.
-    expect(registry.supportsVerb(ApiResourceKind.schedule, Verb.Run)).toBe(false);
+    expect(registry.supportsVerb(ApiResourceKind.schedule, Verb.Run)).toBe(
+      false,
+    );
   });
 
   it("agent_share promises only apply (narrowed — stigmer/stigmer#354)", () => {
-    expect(registry.supportsVerb(ApiResourceKind.agent_share, Verb.Apply)).toBe(true);
+    expect(registry.supportsVerb(ApiResourceKind.agent_share, Verb.Apply)).toBe(
+      true,
+    );
     for (const v of [Verb.Get, Verb.List, Verb.Delete]) {
       expect(registry.supportsVerb(ApiResourceKind.agent_share, v)).toBe(false);
     }
   });
 
   it("session promises apply + list; get/delete stay narrowed (stigmer/stigmer#354, #469)", () => {
-    expect(registry.supportsVerb(ApiResourceKind.session, Verb.Apply)).toBe(true);
-    expect(registry.supportsVerb(ApiResourceKind.session, Verb.List)).toBe(true);
+    expect(registry.supportsVerb(ApiResourceKind.session, Verb.Apply)).toBe(
+      true,
+    );
+    expect(registry.supportsVerb(ApiResourceKind.session, Verb.List)).toBe(
+      true,
+    );
     for (const v of [Verb.Get, Verb.Delete]) {
       expect(registry.supportsVerb(ApiResourceKind.session, v)).toBe(false);
     }
@@ -248,27 +285,33 @@ describe("registry — verb/dispatch conformance", () => {
     },
   ];
 
-  it.each(DISPATCH)("every kind promising '$label' has a dispatch entry", ({ verb, wired, specialCases }) => {
-    for (const info of registry.all()) {
-      if (!info.supportedVerbs.has(verb)) continue;
-      if (specialCases.has(info.kind)) continue;
-      expect(
-        wired.has(info.kind),
-        `${info.name} promises '${verb}' in the verb matrix but has no dispatch entry — ` +
-          "wire it or narrow the matrix (stigmer/stigmer#353, #354)",
-      ).toBe(true);
-    }
-  });
+  it.each(DISPATCH)(
+    "every kind promising '$label' has a dispatch entry",
+    ({ verb, wired, specialCases }) => {
+      for (const info of registry.all()) {
+        if (!info.supportedVerbs.has(verb)) continue;
+        if (specialCases.has(info.kind)) continue;
+        expect(
+          wired.has(info.kind),
+          `${info.name} promises '${verb}' in the verb matrix but has no dispatch entry — ` +
+            "wire it or narrow the matrix (stigmer/stigmer#353, #354)",
+        ).toBe(true);
+      }
+    },
+  );
 
-  it.each(DISPATCH)("every '$label' dispatch entry is promised in the matrix", ({ verb, wired }) => {
-    for (const kind of wired) {
-      expect(
-        registry.supportsVerb(kind, verb),
-        `${ApiResourceKind[kind]} is wired for '${verb}' but the verb matrix does not promise it — ` +
-          "dead dispatch the command-layer gate blocks",
-      ).toBe(true);
-    }
-  });
+  it.each(DISPATCH)(
+    "every '$label' dispatch entry is promised in the matrix",
+    ({ verb, wired }) => {
+      for (const kind of wired) {
+        expect(
+          registry.supportsVerb(kind, verb),
+          `${ApiResourceKind[kind]} is wired for '${verb}' but the verb matrix does not promise it — ` +
+            "dead dispatch the command-layer gate blocks",
+        ).toBe(true);
+      }
+    },
+  );
 
   it("special cases do not shadow a real dispatch entry", () => {
     for (const { label, wired, specialCases } of DISPATCH) {
@@ -292,8 +335,14 @@ describe("registry — verb/dispatch conformance", () => {
 // alias set, so a future bypass for an addressable kind is a red test, not
 // a silently lying `list types` row.
 describe("registry — pre-gate list aliases cannot shadow registered kinds", () => {
-  const PRE_GATE_PREDICATES: ReadonlyArray<{ name: string; matches: (type: string) => boolean }> = [
-    { name: "executions (resources/execution.ts isExecutionAlias)", matches: isExecutionAlias },
+  const PRE_GATE_PREDICATES: ReadonlyArray<{
+    name: string;
+    matches: (type: string) => boolean;
+  }> = [
+    {
+      name: "executions (resources/execution.ts isExecutionAlias)",
+      matches: isExecutionAlias,
+    },
   ];
 
   it("no registered kind's alias is intercepted by a pre-gate predicate", () => {

package/src/registry/registry.ts

@@ -64,7 +64,12 @@ function buildTypeInfo(kind: ApiResourceKind): TypeInfo | undefined {
     // ApiResourceKind[kind] reverse-maps to the proto enum value name (e.g.
     // "oauth_app") — the canonical spelling, taken from the enum itself so it
     // can never drift from the proto.
-    aliases: generateAliases(meta.name, meta.displayName, meta.idPrefix, ApiResourceKind[kind]),
+    aliases: generateAliases(
+      meta.name,
+      meta.displayName,
+      meta.idPrefix,
+      ApiResourceKind[kind],
+    ),
     supportedVerbs: verbsForKind(kind),
   };
 }
@@ -91,7 +96,8 @@ function buildRegistry(): Registry {
     getByAlias: (input) => byAlias.get(normalizeAlias(input)),
     getByYamlKind: (yamlKind) => byYamlKind.get(yamlKind),
     all: () => all,
-    supportsVerb: (kind, verb) => byKind.get(kind)?.supportedVerbs.has(verb) ?? false,
+    supportsVerb: (kind, verb) =>
+      byKind.get(kind)?.supportedVerbs.has(verb) ?? false,
     typesForVerb: (verb) => all.filter((info) => info.supportedVerbs.has(verb)),
   };
 }

package/src/registry/verb-support.ts

@@ -13,50 +13,121 @@
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { Verb } from "./verbs.js";
 
-export const VERB_SUPPORT: ReadonlyMap<ApiResourceKind, ReadonlySet<Verb>> = new Map([
-  [ApiResourceKind.organization, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
+export const VERB_SUPPORT: ReadonlyMap<
+  ApiResourceKind,
+  ReadonlySet<Verb>
+> = new Map([
+  [
+    ApiResourceKind.organization,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete]),
+  ],
   [
     ApiResourceKind.agent,
-    new Set<Verb>([Verb.Apply, Verb.Validate, Verb.Get, Verb.List, Verb.Delete, Verb.Run, Verb.Search]),
+    new Set<Verb>([
+      Verb.Apply,
+      Verb.Validate,
+      Verb.Get,
+      Verb.List,
+      Verb.Delete,
+      Verb.Run,
+      Verb.Search,
+    ]),
   ],
   [
     ApiResourceKind.workflow,
-    new Set<Verb>([Verb.Apply, Verb.Validate, Verb.Get, Verb.List, Verb.Delete, Verb.Run, Verb.Search]),
+    new Set<Verb>([
+      Verb.Apply,
+      Verb.Validate,
+      Verb.Get,
+      Verb.List,
+      Verb.Delete,
+      Verb.Run,
+      Verb.Search,
+    ]),
+  ],
+  [
+    ApiResourceKind.skill,
+    new Set<Verb>([Verb.Get, Verb.List, Verb.Delete, Verb.Push]),
+  ],
+  // A plugin is installed from its folder (`push plugin <dir>`, or `apply`
+  // pointed at one); it is never authored as YAML, so no Validate/Apply of a
+  // document — `validate -f <dir>` reads the folder through the plugin route.
+  [
+    ApiResourceKind.plugin,
+    new Set<Verb>([Verb.Get, Verb.List, Verb.Delete, Verb.Push]),
+  ],
+  [
+    ApiResourceKind.mcp_server,
+    new Set<Verb>([
+      Verb.Apply,
+      Verb.Validate,
+      Verb.Get,
+      Verb.List,
+      Verb.Delete,
+    ]),
   ],
-  [ApiResourceKind.skill, new Set<Verb>([Verb.Get, Verb.List, Verb.Delete, Verb.Push])],
-  [ApiResourceKind.mcp_server, new Set<Verb>([Verb.Apply, Verb.Validate, Verb.Get, Verb.List, Verb.Delete])],
   // Project apply is the stigmer.yaml declarative/synthesis track, not
   // `apply -f project.yaml` — resolveHandlerForKind carries the teaching
   // refusal, and the conformance test documents it as a special case.
-  [ApiResourceKind.project, new Set<Verb>([Verb.Apply, Verb.Validate, Verb.Get, Verb.List, Verb.Delete])],
+  [
+    ApiResourceKind.project,
+    new Set<Verb>([
+      Verb.Apply,
+      Verb.Validate,
+      Verb.Get,
+      Verb.List,
+      Verb.Delete,
+    ]),
+  ],
   [ApiResourceKind.api_key, new Set<Verb>([Verb.Get, Verb.List, Verb.Delete])],
   // agent_execution is special — uses dedicated AgentExecutionQueryController
   // RPCs, not the unified SearchService. delete maps to cancel.
-  [ApiResourceKind.agent_execution, new Set<Verb>([Verb.Get, Verb.List, Verb.Delete, Verb.Download])],
+  [
+    ApiResourceKind.agent_execution,
+    new Set<Verb>([Verb.Get, Verb.List, Verb.Delete, Verb.Download]),
+  ],
   // IAM apps are configured declaratively; read/ops verbs are deliberately
   // not promised (never wired, no demand — stigmer/stigmer#354). To add one:
   // dispatch entry + this line, in the same change.
   [ApiResourceKind.identity_provider, new Set<Verb>([Verb.Apply])],
   [ApiResourceKind.oauth_app, new Set<Verb>([Verb.Apply])],
-  [ApiResourceKind.environment, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
+  [
+    ApiResourceKind.environment,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete]),
+  ],
   // Enable/disable flows through `stigmer share agent`, which is the whole
   // read/ops surface today; only the declarative apply path is promised
   // (stigmer/stigmer#354 records the narrowing).
   [ApiResourceKind.agent_share, new Set<Verb>([Verb.Apply])],
   // The provider install flow is console-driven and cloud-only; the generic
   // verbs cover the declarative path (apply a manifest, inspect, tear down).
-  [ApiResourceKind.agent_channel, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
+  [
+    ApiResourceKind.agent_channel,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete]),
+  ],
   // Secret fields round-trip as ***REDACTED***; applying a fetched manifest
   // preserves the stored secrets (the OAuthApp marker convention).
-  [ApiResourceKind.channel_app, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
+  [
+    ApiResourceKind.channel_app,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete]),
+  ],
   // Firing is the platform's job (Temporal Schedules); the generic verbs
   // cover the declarative path, and get/list surface the state the dedicated
   // `stigmer schedule` commands act on — spec.enabled (the owner's switch)
   // versus status.paused_reason (the platform's failure latch).
-  [ApiResourceKind.schedule, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
-  [ApiResourceKind.agent_instance, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
+  [
+    ApiResourceKind.schedule,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete]),
+  ],
+  [
+    ApiResourceKind.agent_instance,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete]),
+  ],
   // No list: proto exposes getByWorkflow (requires workflow_id), not a generic list.
-  [ApiResourceKind.workflow_instance, new Set<Verb>([Verb.Apply, Verb.Get, Verb.Delete])],
+  [
+    ApiResourceKind.workflow_instance,
+    new Set<Verb>([Verb.Apply, Verb.Get, Verb.Delete]),
+  ],
   // Session list is served by its dedicated query RPC (a LIST_HANDLERS
   // entry); stigmer/stigmer#469 promoted it into the matrix after it shipped
   // working-but-unadvertised through a pre-gate bypass. get/delete remain

package/src/resources/delete.ts

@@ -23,7 +23,12 @@ import type { Stigmer } from "@stigmer/sdk";
 import { CliExitError, ExitCode, UsageError } from "../errors/index.js";
 import { CommandResult } from "../output/index.js";
 import { defaultRegistry, type TypeInfo, Verb } from "../registry/index.js";
-import { cancelAgentExecution, formatAgentPhase, isAgentExecutionId, isExecutionAlias } from "./execution.js";
+import {
+  cancelAgentExecution,
+  formatAgentPhase,
+  isAgentExecutionId,
+  isExecutionAlias,
+} from "./execution.js";
 import { fetchResource } from "./get.js";
 import { getterFor } from "./get-bindings.js";
 import { parseReference } from "./reference.js";
@@ -42,13 +47,22 @@ export interface DeletePlan {
 // the structural slice the delete UI needs. Reading it generically keeps the
 // dispatch kind-agnostic without a per-kind accessor.
 interface HasMetadata {
-  readonly metadata?: { readonly id?: string; readonly name?: string; readonly slug?: string; readonly org?: string };
+  readonly metadata?: {
+    readonly id?: string;
+    readonly name?: string;
+    readonly slug?: string;
+    readonly org?: string;
+  };
 }
 
 // `force` is the RPC-level acknowledgment of destructive side effects —
 // distinct from, but carried by, the CLI's `-f/--force` flag. Kinds whose delete RPC takes a plain typed ID have no
 // force field and simply ignore the argument.
-type DeleteFn = (client: Stigmer, id: string, force: boolean) => Promise<HasMetadata>;
+type DeleteFn = (
+  client: Stigmer,
+  id: string,
+  force: boolean,
+) => Promise<HasMetadata>;
 
 // Kinds the unified delete handles directly, each bound to its SDK delete call.
 // Every kind declaring Delete in the verb matrix must have an entry here (or a
@@ -56,20 +70,33 @@ type DeleteFn = (client: Stigmer, id: string, force: boolean) => Promise<HasMeta
 // enforces it, so the two cannot drift.
 // Kinds whose delete takes a DeleteResourceInput (not an ID) thread the force
 // acknowledgment through — force is the contract's generic ack carrier.
-export const DELETE_HANDLERS: ReadonlyMap<ApiResourceKind, DeleteFn> = new Map<ApiResourceKind, DeleteFn>([
+export const DELETE_HANDLERS: ReadonlyMap<ApiResourceKind, DeleteFn> = new Map<
+  ApiResourceKind,
+  DeleteFn
+>([
   [ApiResourceKind.agent, (c, id) => c.agent.delete(id)],
   [ApiResourceKind.agent_instance, (c, id) => c.agentInstance.delete(id)],
   [ApiResourceKind.workflow, (c, id) => c.workflow.delete(id)],
   [ApiResourceKind.workflow_instance, (c, id) => c.workflowInstance.delete(id)],
-  [ApiResourceKind.mcp_server, (c, id, force) => c.mcpServer.delete({ resourceId: id, force })],
+  [
+    ApiResourceKind.mcp_server,
+    (c, id, force) => c.mcpServer.delete({ resourceId: id, force }),
+  ],
   [ApiResourceKind.project, (c, id) => c.project.delete(id)],
-  [ApiResourceKind.environment, (c, id, force) => c.environment.delete({ resourceId: id, force })],
+  [
+    ApiResourceKind.environment,
+    (c, id, force) => c.environment.delete({ resourceId: id, force }),
+  ],
   [ApiResourceKind.agent_channel, (c, id) => c.agentChannel.delete(id)],
-  [ApiResourceKind.channel_app, (c, id, force) => c.channelapp.delete({ resourceId: id, force })],
+  [
+    ApiResourceKind.channel_app,
+    (c, id, force) => c.channelapp.delete({ resourceId: id, force }),
+  ],
   // A schedule delete also tears down its Temporal Schedule artifact
   // server-side; the RPC takes a bare ScheduleId, so force is ignored.
   [ApiResourceKind.schedule, (c, id) => c.schedule.delete(id)],
   [ApiResourceKind.skill, (c, id) => c.skill.delete(id)],
+  [ApiResourceKind.plugin, (c, id) => c.plugin.delete(id)],
   [ApiResourceKind.api_key, (c, id) => c.apiKey.delete(id)],
 ]);
 
@@ -107,7 +134,9 @@ export async function planDelete(
 
   const info = defaultRegistry().getByAlias(typeArg);
   if (info === undefined) {
-    throw new UsageError(`unknown resource type: ${typeArg}\n\nAvailable types: ${availableDeleteTypes()}`);
+    throw new UsageError(
+      `unknown resource type: ${typeArg}\n\nAvailable types: ${availableDeleteTypes()}`,
+    );
   }
 
   if (info.kind === ApiResourceKind.organization) {
@@ -143,25 +172,38 @@ async function planStandardDelete(
   const parsed = parseReference(reference, org, info.idPrefix);
   // ResourceResult.message is the opaque proto Message; every resource carries
   // the ApiResourceMetadata envelope, so read it through the structural view.
-  const resource = (await getter(client, parsed)).message as unknown as HasMetadata;
+  const resource = (await getter(client, parsed))
+    .message as unknown as HasMetadata;
   const id = metaOf(resource).id;
 
   return {
     warning: buildDeleteWarning(info, resource),
     confirmPrompt: "Proceed with deletion? [y/N]",
-    perform: async () => buildDeleteSuccess(info, await deleteFn(client, id, force)),
+    perform: async () =>
+      buildDeleteSuccess(info, await deleteFn(client, id, force)),
   };
 }
 
-async function planOrganizationDelete(client: Stigmer, reference: string): Promise<DeletePlan> {
+async function planOrganizationDelete(
+  client: Stigmer,
+  reference: string,
+): Promise<DeletePlan> {
   // Organizations are not org-scoped: a bare token is a slug resolved against
   // the caller's memberships (fetchResource handles the id-vs-slug split).
   const parsed = parseReference(reference, "", "org");
-  const resource = (await fetchResource(client, ApiResourceKind.organization, parsed)).message as unknown as HasMetadata;
+  const resource = (
+    await fetchResource(client, ApiResourceKind.organization, parsed)
+  ).message as unknown as HasMetadata;
   const meta = metaOf(resource);
 
-  const warning = CommandResult.warning("You are about to delete the following organization:");
-  warning.addSection("").field("ID", meta.id).field("Name", meta.name).field("Slug", meta.slug);
+  const warning = CommandResult.warning(
+    "You are about to delete the following organization:",
+  );
+  warning
+    .addSection("")
+    .field("ID", meta.id)
+    .field("Name", meta.name)
+    .field("Slug", meta.slug);
   warning.hint("This will delete the organization and all its resources.");
   warning.hint("This action cannot be undone.");
 
@@ -171,7 +213,11 @@ async function planOrganizationDelete(client: Stigmer, reference: string): Promi
     perform: async () => {
       const deleted = metaOf(await client.organization.delete(meta.id));
       const out = CommandResult.success("Organization deleted successfully");
-      out.addSection("Deleted Organization").field("ID", deleted.id).field("Name", deleted.name).field("Slug", deleted.slug);
+      out
+        .addSection("Deleted Organization")
+        .field("ID", deleted.id)
+        .field("Name", deleted.name)
+        .field("Slug", deleted.slug);
       return out;
     },
   };
@@ -185,16 +231,23 @@ function planExecutionCancel(client: Stigmer, reference: string): DeletePlan {
     );
   }
 
-  const warning = CommandResult.warning(`You are about to cancel execution: ${reference}`);
+  const warning = CommandResult.warning(
+    `You are about to cancel execution: ${reference}`,
+  );
   warning.hint("This will gracefully stop the running agent.");
 
   return {
     warning,
     confirmPrompt: "Proceed with cancellation? [y/N]",
     perform: async () => {
-      const { execution, wasAlreadyTerminal } = await cancelAgentExecution(client, reference);
+      const { execution, wasAlreadyTerminal } = await cancelAgentExecution(
+        client,
+        reference,
+      );
       const id = execution.metadata?.id ?? "";
-      const status = formatAgentPhase(execution.status?.phase ?? ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED);
+      const status = formatAgentPhase(
+        execution.status?.phase ?? ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED,
+      );
 
       const out = wasAlreadyTerminal
         ? CommandResult.warning("Execution was already in terminal state")
@@ -207,13 +260,18 @@ function planExecutionCancel(client: Stigmer, reference: string): DeletePlan {
 
 // --- Warning + success rendering (mirrors Go's per-type delete handlers) ---
 
-function buildDeleteWarning(info: TypeInfo, message: HasMetadata): CommandResult {
+function buildDeleteWarning(
+  info: TypeInfo,
+  message: HasMetadata,
+): CommandResult {
   if (info.kind === ApiResourceKind.api_key) {
     return buildApiKeyWarning(message);
   }
 
   const meta = metaOf(message);
-  const warning = CommandResult.warning(`You are about to delete the following ${info.displayName.toLowerCase()}:`);
+  const warning = CommandResult.warning(
+    `You are about to delete the following ${info.displayName.toLowerCase()}:`,
+  );
   const section = warning
     .addSection("")
     .field("ID", meta.id)
@@ -227,10 +285,19 @@ function buildDeleteWarning(info: TypeInfo, message: HasMetadata): CommandResult
     warning.hint("This will delete the skill and all its versions.");
   }
 
+  if (info.kind === ApiResourceKind.plugin) {
+    warning.hint(
+      "This removes the plugin and every skill, MCP server, agent and workflow it installed. " +
+        "It is refused while another agent or workflow of yours still references one of them.",
+    );
+  }
+
   if (info.kind === ApiResourceKind.agent_channel) {
     // The server's documented distinction: delete is the connection's full
     // teardown; disabling is the config-preserving pause.
-    warning.hint("Delete is the connection's full teardown; to pause instead, apply with spec.enabled: false.");
+    warning.hint(
+      "Delete is the connection's full teardown; to pause instead, apply with spec.enabled: false.",
+    );
   }
 
   warning.hint("This action cannot be undone.");
@@ -239,20 +306,28 @@ function buildDeleteWarning(info: TypeInfo, message: HasMetadata): CommandResult
 
 function buildApiKeyWarning(message: HasMetadata): CommandResult {
   const meta = metaOf(message);
-  const warning = CommandResult.warning("You are about to delete the following API key:");
+  const warning = CommandResult.warning(
+    "You are about to delete the following API key:",
+  );
   const section = warning.addSection("").field("ID", meta.id);
   if (meta.name) section.field("Name", meta.name);
-  const fingerprint = (message as { spec?: { fingerprint?: string } }).spec?.fingerprint;
+  const fingerprint = (message as { spec?: { fingerprint?: string } }).spec
+    ?.fingerprint;
   if (fingerprint) section.field("Fingerprint", `***${fingerprint}`);
   warning.hint("This will permanently revoke the API key.");
   warning.hint("This action cannot be undone.");
   return warning;
 }
 
-function buildDeleteSuccess(info: TypeInfo, deleted: HasMetadata): CommandResult {
+function buildDeleteSuccess(
+  info: TypeInfo,
+  deleted: HasMetadata,
+): CommandResult {
   const meta = metaOf(deleted);
   const out = CommandResult.success(`${info.displayName} deleted successfully`);
-  const section = out.addSection(`Deleted ${info.displayName}`).field("ID", meta.id);
+  const section = out
+    .addSection(`Deleted ${info.displayName}`)
+    .field("ID", meta.id);
 
   if (info.kind === ApiResourceKind.api_key) {
     if (meta.name) section.field("Name", meta.name);
@@ -263,7 +338,12 @@ function buildDeleteSuccess(info: TypeInfo, deleted: HasMetadata): CommandResult
   return out;
 }
 
-function metaOf(message: HasMetadata): { id: string; name: string; slug: string; org: string } {
+function metaOf(message: HasMetadata): {
+  id: string;
+  name: string;
+  slug: string;
+  org: string;
+} {
   return {
     id: message.metadata?.id ?? "",
     name: message.metadata?.name ?? "",