argsbarg 6.1.9 → 6.2.0

package/src/configure/artifacts/target-skill.ts

@@ -19,25 +19,17 @@ export interface SkillHostSpec {
   actionKind: InstallActionKind;
   label: string;
   uninstallPrefix: string;
-  pairedMcpKey: CliInstallArtifactKey;
   skillDir: (paths: InstallPaths) => string;
-  detectedKey: keyof Pick<
-    InstalledArtifacts,
-    "cursorSkill" | "claudeSkill" | "codexSkill" | "opencodeSkill" | "openclawSkill"
-  >;
-  statusField: keyof Pick<
-    InstallStatus,
-    "cursorSkill" | "claudeSkill" | "codexSkill" | "opencodeSkill" | "openclawSkill"
-  >;
+  detectedKey: "skill";
+  statusField: "skill";
   isAvailable: (root: CliProgram, paths: InstallPaths) => boolean;
 }
 
-/** Agent shell skill directory install. */
+/** Agent shell skill directory install (`~/.agents/skills/<key>/`). */
 export class SkillInstallTarget extends InstallTarget {
   readonly key: CliInstallArtifactKey;
   readonly actionKind: InstallActionKind;
   readonly category = "skill" as const;
-  readonly pairedKey: CliInstallArtifactKey;
   readonly uninstallPrefix: string;
 
   private readonly spec: SkillHostSpec;
@@ -47,7 +39,6 @@ export class SkillInstallTarget extends InstallTarget {
     this.spec = spec;
     this.key = spec.key;
     this.actionKind = spec.actionKind;
-    this.pairedKey = spec.pairedMcpKey;
     this.uninstallPrefix = spec.uninstallPrefix;
   }
 
@@ -84,8 +75,8 @@ export class SkillInstallTarget extends InstallTarget {
     return [
       {
         kind: this.actionKind,
-        summary: `${this.spec.label.toLowerCase()} skill: ${displayInstallPath(dir)}/`,
-        message: `Installing ${this.spec.label} skill to ${displayInstallPath(dir)}/`,
+        summary: `${this.spec.label.toLowerCase()}: ${displayInstallPath(dir)}/`,
+        message: `Installing ${this.spec.label.toLowerCase()} to ${displayInstallPath(dir)}/`,
         run: () => [],
       },
     ];
@@ -97,7 +88,7 @@ export class SkillInstallTarget extends InstallTarget {
       {
         kind: this.actionKind,
         summary: `${this.uninstallPrefix}: ${displayInstallPath(dir)}/`,
-        message: `Removing ${this.spec.label} skill ${displayInstallPath(dir)}/`,
+        message: `Removing ${this.spec.label.toLowerCase()} ${displayInstallPath(dir)}/`,
         run: () => uninstallSkillDir(dir, ctx.dry),
       },
     ];

package/src/configure/artifacts/target-types.ts

@@ -14,37 +14,9 @@ export interface InstallScope {
 }
 
 /** Artifact keys for install.targets. */
-export type CliInstallArtifactKey =
-  | "app"
-  | "chatgptMcp"
-  | "claudeCodeMcp"
-  | "claudeDesktopMcp"
-  | "claudeSkill"
-  | "codexMcp"
-  | "codexSkill"
-  | "configure"
-  | "cursorMcp"
-  | "cursorSkill"
-  | "openclawMcp"
-  | "openclawSkill"
-  | "opencodeMcp"
-  | "opencodeSkill";
+export type CliInstallArtifactKey = "app" | "agentsMcp" | "configure" | "skill";
 
-export type InstallActionKind =
-  | "app"
-  | "cursor-skill"
-  | "claude-skill"
-  | "codex-skill"
-  | "opencode-skill"
-  | "openclaw-skill"
-  | "cursor-mcp"
-  | "claude-mcp"
-  | "claude-desktop-mcp"
-  | "opencode-mcp"
-  | "codex-mcp"
-  | "openclaw-mcp"
-  | "chatgpt-desktop-mcp"
-  | "configure";
+export type InstallActionKind = "app" | "agent-skill" | "agents-mcp" | "configure";
 
 export type InstallTargetCategory = "core" | "skill" | "mcp";
 
@@ -64,34 +36,14 @@ export interface UninstallAction {
 
 export interface InstalledArtifacts {
   app: boolean;
-  cursorSkill: boolean;
-  claudeSkill: boolean;
-  codexSkill: boolean;
-  opencodeSkill: boolean;
-  openclawSkill: boolean;
-  cursorMcp: boolean;
-  claudeMcp: boolean;
-  claudeDesktopMcp: boolean;
-  opencodeMcp: boolean;
-  codexMcp: boolean;
-  openclawMcp: boolean;
-  chatGptMcp: boolean;
+  skill: boolean;
+  agentsMcp: boolean;
 }
 
 export interface InstallStatus {
   app?: string;
-  cursorSkill?: string;
-  claudeSkill?: string;
-  codexSkill?: string;
-  opencodeSkill?: string;
-  openclawSkill?: string;
-  cursorMcp?: string;
-  claudeMcp?: string;
-  claudeDesktopMcp?: string;
-  opencodeMcp?: string;
-  codexMcp?: string;
-  openclawMcp?: string;
-  chatGptMcp?: string;
+  skill?: string;
+  agentsMcp?: string;
 }
 
 export interface DetectedSnapshot extends InstalledArtifacts {

package/src/configure/artifacts/targets/agents-mcp.ts

@@ -0,0 +1,11 @@
+import { McpJsonInstallTarget } from "../target-mcp-json.ts";
+
+export const agentsMcpTarget = new McpJsonInstallTarget({
+  key: "agentsMcp",
+  actionKind: "agents-mcp",
+  label: "agents mcp",
+  configPath: (p) => p.agentsMcpPath,
+  detectedKey: "agentsMcp",
+  statusField: "agentsMcp",
+  isAvailable: (_root, _paths) => true,
+});

package/src/configure/artifacts/targets/configure.ts

@@ -1,5 +1,5 @@
 import { appConfigInstalled, displayAppConfigPath, uninstallAppConfig } from "../../../config/file.ts";
-import type { CliProgram, InstallAgentIntegration } from "../../../core/types.ts";
+import type { CliProgram } from "../../../core/types.ts";
 import type { InstallPaths } from "../paths.ts";
 import { InstallTarget } from "../target-base.ts";
 import type {
@@ -17,10 +17,6 @@ class ConfigureInstallTarget extends InstallTarget {
   readonly actionKind = "configure" as const;
   readonly category = "core" as const;
 
-  defaultIncludedInAll(_integration: InstallAgentIntegration): boolean {
-    return false;
-  }
-
   isAvailable(root: CliProgram, _paths: InstallPaths): boolean {
     return root.appConfig !== undefined;
   }

package/src/configure/artifacts/targets/index.ts

@@ -1,50 +1,10 @@
 import type { InstallTarget } from "../target-base.ts";
+import { agentsMcpTarget } from "./agents-mcp.ts";
 import { appTarget } from "./app.ts";
-import { chatgptMcpTarget } from "./chatgpt-mcp.ts";
-import { claudeCodeMcpTarget } from "./claude-code-mcp.ts";
-import { claudeDesktopMcpTarget } from "./claude-desktop-mcp.ts";
-import { claudeSkillTarget } from "./claude-skill.ts";
-import { codexMcpTarget } from "./codex-mcp.ts";
-import { codexSkillTarget } from "./codex-skill.ts";
 import { configureTarget } from "./configure.ts";
-import { cursorMcpTarget } from "./cursor-mcp.ts";
-import { cursorSkillTarget } from "./cursor-skill.ts";
-import { openclawMcpTarget } from "./openclaw-mcp.ts";
-import { openclawSkillTarget } from "./openclaw-skill.ts";
-import { opencodeMcpTarget } from "./opencode-mcp.ts";
-import { opencodeSkillTarget } from "./opencode-skill.ts";
+import { skillTarget } from "./skill.ts";
 
 /** Ordered install targets (plan iteration order). */
-export const INSTALL_TARGETS: InstallTarget[] = [
-  appTarget,
-  cursorSkillTarget,
-  claudeSkillTarget,
-  codexSkillTarget,
-  opencodeSkillTarget,
-  openclawSkillTarget,
-  cursorMcpTarget,
-  claudeCodeMcpTarget,
-  claudeDesktopMcpTarget,
-  opencodeMcpTarget,
-  codexMcpTarget,
-  openclawMcpTarget,
-  chatgptMcpTarget,
-  configureTarget,
-];
+export const INSTALL_TARGETS: InstallTarget[] = [appTarget, skillTarget, agentsMcpTarget, configureTarget];
 
-export {
-  appTarget,
-  chatgptMcpTarget,
-  claudeCodeMcpTarget,
-  claudeDesktopMcpTarget,
-  claudeSkillTarget,
-  codexMcpTarget,
-  codexSkillTarget,
-  configureTarget,
-  cursorMcpTarget,
-  cursorSkillTarget,
-  openclawMcpTarget,
-  openclawSkillTarget,
-  opencodeMcpTarget,
-  opencodeSkillTarget,
-};
+export { agentsMcpTarget, appTarget, configureTarget, skillTarget };

package/src/configure/artifacts/targets/skill.ts

@@ -0,0 +1,12 @@
+import { SkillInstallTarget } from "../target-skill.ts";
+
+export const skillTarget = new SkillInstallTarget({
+  key: "skill",
+  actionKind: "agent-skill",
+  label: "Agent skill",
+  uninstallPrefix: "agent skill",
+  skillDir: (p) => p.agentsSkillDir,
+  detectedKey: "skill",
+  statusField: "skill",
+  isAvailable: (root) => root.skill?.enabled === true,
+});

package/src/configure/artifacts/targets.test.ts

@@ -6,7 +6,7 @@ import { describe, expect, test } from "bun:test";
 import type { CliProgram } from "../../core/types.ts";
 import { normalizeInstallRawOpts } from "./normalize.ts";
 import { normalizeUninstallRawOpts } from "./normalize-uninstall.ts";
-import { resolveAgentIntegration, resolveEffectiveInstallTargets } from "./target-effective.ts";
+import { resolveEffectiveInstallTargets } from "./target-effective.ts";
 import { isArtifactInScope } from "./target-scope.ts";
 
 /** Tests for normalizeInstallRawOpts. */
@@ -27,17 +27,6 @@ describe("normalizeInstallRawOpts", () => {
   });
 });
 
-/** Tests for resolveAgentIntegration. */
-describe("resolveAgentIntegration", () => {
-  test("defaults to skill without MCP", () => {
-    expect(resolveAgentIntegration(undefined, false)).toBe("skill");
-  });
-
-  test("defaults to mcp when MCP enabled", () => {
-    expect(resolveAgentIntegration(undefined, true)).toBe("mcp");
-  });
-});
-
 /** Tests for resolveEffectiveInstallTargets. */
 describe("resolveEffectiveInstallTargets", () => {
   test("defaults app and configure not in --all", () => {
@@ -46,77 +35,50 @@ describe("resolveEffectiveInstallTargets", () => {
     expect(t.configure.includedInAll).toBe(false);
   });
 
-  test("skill mode includes skills in --all not MCP pairs", () => {
-    const program: Pick<CliProgram, "mcpServer"> = {};
-    const t = resolveEffectiveInstallTargets(undefined, program);
-    expect(t.cursorSkill.includedInAll).toBe(true);
-    expect(t.cursorSkill.enabled).toBe(true);
-    expect(t.cursorMcp.includedInAll).toBe(false);
-    expect(t.cursorMcp.enabled).toBe(false);
+  test("skill disabled by default", () => {
+    const t = resolveEffectiveInstallTargets(undefined, {});
+    expect(t.skill.enabled).toBe(false);
+    expect(t.skill.includedInAll).toBe(false);
+    expect(t.agentsMcp.includedInAll).toBe(false);
   });
 
-  test("mcp mode includes MCP in --all not paired skills", () => {
-    const program: Pick<CliProgram, "mcpServer"> = { mcpServer: { enabled: true } };
-    const t = resolveEffectiveInstallTargets(undefined, program);
-    expect(t.cursorMcp.includedInAll).toBe(true);
-    expect(t.cursorSkill.includedInAll).toBe(false);
-    expect(t.claudeDesktopMcp.includedInAll).toBe(true);
+  test("skill enabled via program.skill", () => {
+    const t = resolveEffectiveInstallTargets(undefined, { skill: { enabled: true } });
+    expect(t.skill.enabled).toBe(true);
+    expect(t.skill.includedInAll).toBe(true);
   });
 
-  test("both mode includes MCP and skills", () => {
+  test("agentsMcp in --all when mcpServer enabled", () => {
     const program: Pick<CliProgram, "mcpServer"> = { mcpServer: { enabled: true } };
-    const t = resolveEffectiveInstallTargets({ agentIntegration: "both" }, program);
-    expect(t.cursorMcp.includedInAll).toBe(true);
-    expect(t.cursorSkill.includedInAll).toBe(true);
-  });
-
-  test("per-key override disables one skill", () => {
-    const t = resolveEffectiveInstallTargets({
-      targets: { cursorSkill: false },
-    });
-    expect(t.claudeSkill.includedInAll).toBe(true);
-    expect(t.cursorSkill.enabled).toBe(false);
+    const t = resolveEffectiveInstallTargets(undefined, program);
+    expect(t.agentsMcp.enabled).toBe(true);
+    expect(t.agentsMcp.includedInAll).toBe(true);
+    expect(t.skill.includedInAll).toBe(false);
   });
 
-  /** Scoped --mcp uses effective targets not all MCP hosts. */
-  test("scoped --mcp uses effective targets not all MCP hosts", () => {
+  test("scoped --mcp includes agentsMcp when mcpServer enabled", () => {
     const program: CliProgram = {
       key: "app",
       version: "1",
       description: "x",
       mcpServer: { enabled: true },
-      configure: { agentIntegration: "skill" },
       handler: () => {},
     };
     const effective = resolveEffectiveInstallTargets(program.configure, program);
     const scope = { mcp: true };
-    expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(false);
-    expect(
-      isArtifactInScope(
-        "cursorMcp",
-        scope,
-        resolveEffectiveInstallTargets({ targets: { cursorMcp: true }, agentIntegration: "both" }, program),
-        "install-scoped",
-        program,
-      ),
-    ).toBe(true);
+    expect(isArtifactInScope("agentsMcp", scope, effective, "install-scoped", program)).toBe(true);
   });
 
-  /** Scoped --mcp --skill --configure includes skill and mcp not only configure. */
-  test("scoped --mcp --skill --configure includes skill and mcp not only configure", () => {
+  test("scoped --skill includes skill when program.skill.enabled", () => {
     const program: CliProgram = {
       key: "app",
       version: "1",
       description: "x",
-      mcpServer: { enabled: true },
-      configure: { agentIntegration: "both" },
+      skill: { enabled: true },
       handler: () => {},
     };
     const effective = resolveEffectiveInstallTargets(program.configure, program);
-    const scope = { mcp: true, skill: true, configure: true };
-    expect(isArtifactInScope("cursorSkill", scope, effective, "install-scoped", program)).toBe(true);
-    expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(true);
-    expect(isArtifactInScope("configure", scope, effective, "install-scoped", program)).toBe(true);
-    expect(isArtifactInScope("claudeSkill", scope, effective, "install-scoped", program)).toBe(true);
+    const scope = { skill: true };
+    expect(isArtifactInScope("skill", scope, effective, "install-scoped", program)).toBe(true);
   });
 });

package/src/configure/configure.test.ts

@@ -28,6 +28,7 @@ const fixture: CliProgram = {
   version: "0.0.0",
   description: "Test",
   mcpServer: { enabled: true },
+  skill: { enabled: true },
   handler: () => {},
 };
 
@@ -72,7 +73,7 @@ describe("configure opts", () => {
 describe("configure mutation summary", () => {
   test("interactive uninstall reports removed artifacts not file count", () => {
     const msg = formatConfigureMutationSummary(
-      { paths: ["~/.cursor/skills/testapp/"], installed: 0, removed: 1, configured: 0 },
+      { paths: ["~/.agents/skills/testapp/"], installed: 0, removed: 1, configured: 0 },
       {},
     );
     expect(msg).toBe("Removed 1 artifact.");
@@ -81,7 +82,7 @@ describe("configure mutation summary", () => {
   test("interactive install reports installed artifacts not file count", () => {
     const msg = formatConfigureMutationSummary(
       {
-        paths: ["~/.cursor/skills/testapp/SKILL.md", "~/.cursor/skills/testapp/reference.md"],
+        paths: ["~/.agents/skills/testapp/SKILL.md", "~/.agents/skills/testapp/reference.md"],
         installed: 1,
         removed: 0,
         configured: 0,
@@ -110,10 +111,10 @@ describe("configure mutation summary", () => {
 
 /** Tests for install paths. */
 describe("install paths", () => {
-  test("resolveInstallPaths includes skill and mcp paths", () => {
+  test("resolveInstallPaths includes agents skill and mcp paths", () => {
     const paths = resolveInstallPaths(fixture);
-    expect(paths.cursorSkillDir).toContain(".cursor/skills");
-    expect(paths.cursorMcpPath).toContain("mcp.json");
+    expect(paths.agentsSkillDir).toContain(".agents/skills");
+    expect(paths.agentsMcpPath).toContain(".agents/mcp.json");
   });
 
   test("claude desktop mcp path on darwin", () => {
@@ -131,28 +132,28 @@ describe("install paths", () => {
 
 /** Tests for detect installed. */
 describe("detect installed", () => {
-  /** Detects cursor mcp when configured. */
-  test("detects cursor mcp when configured", () => {
+  test("detects agents mcp when configured", () => {
     const paths = resolveInstallPaths(fixture);
-    mkdirSync(join(home, ".cursor"), { recursive: true });
+    mkdirSync(join(home, ".agents"), { recursive: true });
     writeFileSync(
-      paths.cursorMcpPath,
+      paths.agentsMcpPath,
       JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
       "utf8",
     );
 
     const detected = detectInstalledArtifacts(paths, fixture);
-    expect(detected.cursorMcp).toBe(true);
+    expect(detected.agentsMcp).toBe(true);
     expect(detected.app).toBe(false);
   });
 });
 
 /** Tests for sync plan. */
 describe("sync plan", () => {
-  test("buildUpdatePlan greenfield includes agent targets", () => {
+  test("buildUpdatePlan greenfield includes skill when enabled", () => {
     const paths = resolveInstallPaths(fixture);
     const plan = buildUpdatePlan(fixture, paths, parseInstallOpts({ reinstall: "1", yes: "1" }));
     expect(plan.length).toBeGreaterThan(0);
+    expect(plan.some((a) => a.kind === "agent-skill")).toBe(true);
     expect(plan.some((a) => a.kind === "app")).toBe(false);
   });
 
@@ -160,19 +161,14 @@ describe("sync plan", () => {
     const paths = resolveInstallPaths(fixture);
     const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
     expect(plan.some((a) => a.kind === "app")).toBe(false);
-    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+    expect(plan.some((a) => a.kind === "agent-skill")).toBe(true);
+    expect(plan.some((a) => a.kind === "agents-mcp")).toBe(true);
   });
 
-  test("buildInstallPlan respects configure.agentIntegration skill", () => {
-    const skillApp: CliProgram = {
-      ...fixture,
-      configure: { agentIntegration: "skill" },
-    };
-    const paths = resolveInstallPaths(skillApp);
-    mkdirSync(join(home, ".claude"), { recursive: true });
-    mkdirSync(join(home, ".cursor"), { recursive: true });
-    const plan = buildInstallPlan(skillApp, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(false);
+  test("buildInstallPlan --mcp scoped includes agentsMcp when mcp enabled", () => {
+    const paths = resolveInstallPaths(fixture);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
+    expect(plan.some((a) => a.kind === "agents-mcp")).toBe(true);
   });
 });
 
@@ -184,43 +180,35 @@ describe("remove plan", () => {
     expect(plan.length).toBe(0);
   });
 
-  test("configure --remove-all removes installed cursor skill", async () => {
-    const skillApp: CliProgram = {
-      ...fixture,
-      configure: { agentIntegration: "skill" },
-    };
-    const paths = resolveInstallPaths(skillApp);
-    mkdirSync(paths.cursorSkillDir, { recursive: true });
-    writeFileSync(join(paths.cursorSkillDir, "SKILL.md"), "# test\n", "utf8");
+  test("configure --remove-all removes installed agent skill", async () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.agentsSkillDir, { recursive: true });
+    writeFileSync(join(paths.agentsSkillDir, "SKILL.md"), "# test\n", "utf8");
 
-    expect(detectInstalledArtifacts(paths, skillApp).cursorSkill).toBe(true);
+    expect(detectInstalledArtifacts(paths, fixture).skill).toBe(true);
 
-    const result = await new Cli(skillApp).invoke(["configure", "--remove-all", "--yes"]);
+    const result = await new Cli(fixture).invoke(["configure", "--remove-all", "--yes"]);
     expect(result.exitCode).toBe(0);
-    expect(existsSync(paths.cursorSkillDir)).toBe(false);
+    expect(existsSync(paths.agentsSkillDir)).toBe(false);
   });
 
-  test("scoped skill uninstall action removes directory without global uninstall flag", () => {
-    const skillApp: CliProgram = {
-      ...fixture,
-      configure: { agentIntegration: "skill" },
-    };
-    const paths = resolveInstallPaths(skillApp);
-    mkdirSync(paths.cursorSkillDir, { recursive: true });
-    writeFileSync(join(paths.cursorSkillDir, "SKILL.md"), "# test\n", "utf8");
+  test("scoped skill uninstall action removes directory", () => {
+    const paths = resolveInstallPaths(fixture);
+    mkdirSync(paths.agentsSkillDir, { recursive: true });
+    writeFileSync(join(paths.agentsSkillDir, "SKILL.md"), "# test\n", "utf8");
 
-    const detected = buildDetectedSnapshot(skillApp, paths);
-    const ctx = buildTargetPlanContext(skillApp, paths, {}, detected);
-    const target = installTargetForKey("cursorSkill");
+    const detected = buildDetectedSnapshot(fixture, paths);
+    const ctx = buildTargetPlanContext(fixture, paths, {}, detected);
+    const target = installTargetForKey("skill");
     expect(target).toBeDefined();
     const actions = target!.planUninstall({
       ...ctx,
       mode: "uninstall-scoped",
-      include: (key) => key === "cursorSkill",
+      include: (key) => key === "skill",
     });
     expect(actions).toHaveLength(1);
     expect(actions[0]!.run().length).toBeGreaterThan(0);
-    expect(existsSync(paths.cursorSkillDir)).toBe(false);
+    expect(existsSync(paths.agentsSkillDir)).toBe(false);
   });
 });
 
@@ -247,6 +235,7 @@ describe("configure --sync bootstrap", () => {
       key: "syncboot",
       version: "0.0.0",
       description: "Sync bootstrap test.",
+      skill: { enabled: true },
       handler: () => {},
       configure: { enabled: true },
     };

package/src/configure/index.ts

@@ -6,8 +6,8 @@ import { displayAppConfigPath, runConfigure } from "../config/bootstrap.ts";
 import { ensureAppConfigFile } from "../config/file.ts";
 import type { CliProgram } from "../core/types.ts";
 import { resolveCapabilities } from "../runtime/capabilities.ts";
-import { cliSkillInstall, skillTargetFromActionKind } from "../skill/install.ts";
-import { resolveInstallPaths } from "./artifacts/paths.ts";
+import { cliSkillInstall, isAgentSkillActionKind } from "../skill/install.ts";
+import { displayInstallPath, resolveInstallPaths } from "./artifacts/paths.ts";
 import { buildInstallPlan, buildUpdatePlan } from "./artifacts/plan.ts";
 import {
   installErr,
@@ -23,7 +23,6 @@ import { buildDetectedSnapshot, buildTargetPlanContext } from "./artifacts/targe
 import type {
   CliInstallArtifactKey,
   InstallAction,
-  InstallActionKind,
   InstallOpts,
   TargetPlanContext,
   UninstallAction,
@@ -94,11 +93,9 @@ function configureToInstallOpts(opts: ConfigureOpts): InstallOpts {
   return { dry: opts.dry, json: opts.json };
 }
 
-/** Installs a skill target and returns changed paths. */
-function runSkillAction(root: CliProgram, kind: InstallActionKind, opts: InstallOpts): string[] {
-  const target = skillTargetFromActionKind(kind);
-  if (!target) return [];
-  return cliSkillInstall(root, target, {
+/** Installs the agent skill bundle and returns changed paths. */
+function runSkillAction(root: CliProgram, opts: InstallOpts): string[] {
+  return cliSkillInstall(root, {
     global: true,
     rimraf: true,
     dry: opts.dry,
@@ -171,17 +168,14 @@ function runPlanAction(
   opts: InstallOpts,
   paths: ReturnType<typeof resolveInstallPaths>,
 ): string[] {
-  if ("kind" in action && action.kind) {
-    const skillTarget = skillTargetFromActionKind(action.kind);
-    if (skillTarget) {
-      const runResult = action.run();
-      if (runResult.length > 0) return runResult;
-      if (opts.uninstall) {
-        const skillDir = skillDirFromUninstallSummary(action.summary, paths);
-        return skillDir ? uninstallSkillDir(skillDir, !!opts.dry) : [];
-      }
-      return runSkillAction(root, action.kind as InstallActionKind, opts);
+  if ("kind" in action && action.kind && isAgentSkillActionKind(action.kind)) {
+    const runResult = action.run();
+    if (runResult.length > 0) return runResult;
+    if (opts.uninstall) {
+      const skillDir = skillDirFromUninstallSummary(action.summary, paths);
+      return skillDir ? uninstallSkillDir(skillDir, !!opts.dry) : [];
     }
+    return runSkillAction(root, opts);
   }
   if (!("kind" in action) || !action.kind) {
     const skillDir = skillDirFromUninstallSummary(action.summary, paths);
@@ -205,6 +199,12 @@ function executePlan(
     }
     const changed = runPlanAction(root, action, opts, paths);
     if (changed.length === 0) continue;
+    if (action.kind === "agent-skill" && !opts.uninstall && !opts.dry) {
+      installOut(`Skill installed to ${displayInstallPath(paths.agentsSkillDir)}/`, opts);
+    }
+    if (action.kind === "agents-mcp" && !opts.uninstall && !opts.dry) {
+      installOut(`MCP server registered in ${displayInstallPath(paths.agentsMcpPath)}`, opts);
+    }
     if (action.kind === "configure") {
       recordArtifactMutation(summary, changed, opts.uninstall ? "removed" : "configured");
     } else {
@@ -264,7 +264,7 @@ async function runInteractiveConfigure(root: CliProgram, opts: ConfigureOpts): P
   const summary = emptyMutationSummary();
 
   for (const target of INSTALL_TARGETS) {
-    if (target.key === "app") continue;
+    if (target.key === "app" || target.key === "skill" || target.key === "agentsMcp") continue;
     if (!effective[target.key].enabled) continue;
     if (target.key !== "configure" && !target.isAvailable(root, paths)) continue;
     if (target.key === "configure" && !root.appConfig) continue;

package/src/configure/prompt.ts

@@ -8,18 +8,8 @@ import type { CliInstallArtifactKey } from "./artifacts/target-types.ts";
 /** Human-readable labels for each install artifact key in interactive prompts. */
 const LABELS: Record<CliInstallArtifactKey, string> = {
   app: "App binary",
-  cursorSkill: "Cursor skill",
-  claudeSkill: "Claude skill",
-  codexSkill: "Codex skill",
-  opencodeSkill: "OpenCode skill",
-  openclawSkill: "OpenClaw skill",
-  cursorMcp: "Cursor MCP",
-  claudeCodeMcp: "Claude Code MCP",
-  claudeDesktopMcp: "Claude Desktop MCP",
-  opencodeMcp: "OpenCode MCP",
-  codexMcp: "Codex MCP",
-  openclawMcp: "OpenClaw MCP",
-  chatgptMcp: "ChatGPT desktop MCP",
+  skill: "Agent skill",
+  agentsMcp: "Agents MCP",
   configure: "App config",
 };