argsbarg 6.1.10 → 6.2.2

package/src/cli-tool/run-create.ts

@@ -6,13 +6,14 @@ import {
   applyCreate,
   type CreateOptions,
   diffCreateDetails,
+  normalizeCreateTemplateId,
   parseCreateArgv,
   printCreateDiffs,
   renderCreateTree,
   resolveCreateOptions,
 } from "./create.ts";
 import { printPostCreatePlan, runPostCreate } from "./post-create.ts";
-import { promptConfirm, promptOptional, promptRequired } from "./prompt.ts";
+import { promptConfirm, promptOptional, promptRequired, promptTemplateChoice } from "./prompt.ts";
 
 function isInteractiveTty(): boolean {
   return Boolean(process.stdin.isTTY);
@@ -22,7 +23,10 @@ function collectInteractiveOptions(
   partial: Partial<CreateOptions>,
   dir: string,
 ): { opts: CreateOptions; baseDir: string } {
-  process.stderr.write("Argsbarg create — bootstrap a new CLI from full-example\n\n");
+  process.stderr.write("Argsbarg create — bootstrap a new CLI\n\n");
+
+  const templateId = partial.templateId ?? promptTemplateChoice();
+
   const targetDir = promptOptional("Target directory", dir) ?? dir;
   const baseDir = resolve(process.cwd(), targetDir);
   const key = promptRequired("CLI key (binary name)", partial.key);
@@ -31,6 +35,7 @@ function collectInteractiveOptions(
   const opts = resolveCreateOptions(
     {
       ...partial,
+      templateId,
       key,
       releaseRepo,
       force: partial.force ?? false,
@@ -38,7 +43,8 @@ function collectInteractiveOptions(
     baseDir,
   );
 
-  process.stderr.write(`\nTarget: ${baseDir}\n`);
+  process.stderr.write(`\nTemplate: ${opts.templateId}\n`);
+  process.stderr.write(`Target: ${baseDir}\n`);
   process.stderr.write(`Key: ${opts.key}  Class: ${opts.className}  Tap: ${opts.tap}  Release: ${opts.releaseRepo}\n`);
   process.stderr.write(`Homepage: ${opts.homepage}\n\n`);
   const tree = renderCreateTree(opts);
@@ -47,7 +53,7 @@ function collectInteractiveOptions(
     process.stderr.write(`  ${rel}\n`);
   }
   process.stderr.write("\n");
-  printPostCreatePlan();
+  printPostCreatePlan(opts.templateId);
   process.stderr.write("\n");
 
   if (!promptConfirm("Proceed")) {
@@ -91,7 +97,13 @@ export async function runCreate(input: Partial<CreateOptions> & { dir?: string }
     if (!partial.releaseRepo) {
       throw new Error("--release-repo is required in non-interactive mode.");
     }
-    opts = resolveCreateOptions(partial, baseDir);
+    opts = resolveCreateOptions(
+      {
+        ...partial,
+        templateId: normalizeCreateTemplateId(partial.templateId),
+      },
+      baseDir,
+    );
     return runCreateApply(baseDir, opts, partial.dryRun ?? false);
   } catch (err) {
     process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
@@ -104,7 +116,7 @@ async function runCreateApply(baseDir: string, opts: CreateOptions, dryRun: bool
     const written = applyCreate(baseDir, { ...opts, dryRun: true, check: false });
     process.stdout.write(`Would write ${written.length} file(s) under ${baseDir}\n`);
     for (const w of written) process.stdout.write(`  ${relative(baseDir, w) || w}\n`);
-    printPostCreatePlan();
+    printPostCreatePlan(opts.templateId);
     return 0;
   }
 
@@ -120,7 +132,7 @@ async function runCreateApply(baseDir: string, opts: CreateOptions, dryRun: bool
     process.stdout.write(`  ${relative(baseDir, w) || w}\n`);
   }
 
-  await runPostCreate(baseDir, false);
+  await runPostCreate(baseDir, false, opts.templateId);
   process.stdout.write("Done.\n");
   return 0;
 }

package/src/cli-tool/schemagen/schemagen.test.ts

@@ -6,7 +6,7 @@ import { discoverSchemaRoots } from "./discover-schema-roots.ts";
 import { schemaExportName, schemaJsonBasename } from "./names.ts";
 import { runSchemagen } from "./run.ts";
 
-const exampleRoot = join(import.meta.dir, "../../../examples/full-example");
+const exampleRoot = join(import.meta.dir, "../../../examples/full-example-json");
 
 const tempRoots: string[] = [];
 
@@ -46,7 +46,7 @@ function writeSrcFile(root: string, relPath: string, body: string): void {
 }
 
 describe("schemagen", () => {
-  test("discovers @sg types in full-example", () => {
+  test("discovers @sg types in full-example-json", () => {
     const roots = discoverSchemaRoots(exampleRoot);
     expect(roots.map((r) => r.typeName).sort()).toEqual(["RenderJsonInput", "StatusJsonOutput", "WorkspaceNameInput"]);
   });
@@ -56,7 +56,7 @@ describe("schemagen", () => {
     expect(schemaExportName("RenderJsonInput")).toBe("RenderJsonInputSchema");
   });
 
-  test("runSchemagen writes __generated__ artifacts in full-example", () => {
+  test("runSchemagen writes __generated__ artifacts in full-example-json", () => {
     const counts = runSchemagen({ projectRoot: exampleRoot });
     expect(counts).toEqual({ schemas: 3 });
   });

package/src/configure/artifacts/install-validate.test.ts

@@ -29,49 +29,36 @@ describe("validateConfigureConfig", () => {
     expect(() => cliValidateProgram(program)).toThrow(/allSkills/);
   });
 
-  test("rejects both sides of pair without both integration", () => {
-    const program: CliProgram = {
+  test("rejects configure.agentIntegration", () => {
+    const program = {
       ...base,
-      mcpServer: { enabled: true },
-      configure: {
-        agentIntegration: "mcp",
-        targets: { cursorMcp: true, cursorSkill: true },
-      },
-    };
-    expect(() => cliValidateProgram(program)).toThrow(/both/);
+      configure: { agentIntegration: "mcp" },
+    } as CliProgram;
+    expect(() => cliValidateProgram(program)).toThrow(/agentIntegration removed/);
   });
 
-  test("rejects explicit MCP target in skill integration mode", () => {
-    const program: CliProgram = {
+  test("rejects legacy per-host skill targets", () => {
+    const program = {
       ...base,
-      configure: {
-        agentIntegration: "skill",
-        targets: { cursorMcp: true },
-      },
-    };
-    expect(() => cliValidateProgram(program)).toThrow(/cursorMcp/);
+      configure: { targets: { cursorSkill: true } },
+    } as CliProgram;
+    expect(() => cliValidateProgram(program)).toThrow(/cursorSkill removed/);
   });
 
-  test("allows explicit pair targets with both integration", () => {
-    const program: CliProgram = {
+  test("rejects legacy per-host MCP targets", () => {
+    const program = {
       ...base,
       mcpServer: { enabled: true },
-      configure: {
-        agentIntegration: "both",
-        targets: { cursorMcp: true, cursorSkill: true },
-      },
-    };
-    expect(() => cliValidateProgram(program)).not.toThrow();
+      configure: { targets: { cursorMcp: true } },
+    } as CliProgram;
+    expect(() => cliValidateProgram(program)).toThrow(/cursorMcp removed/);
   });
 
-  test("rejects explicit MCP target without mcpServer", () => {
-    const program: CliProgram = {
+  test("rejects unknown configure.targets keys", () => {
+    const program = {
       ...base,
-      configure: {
-        agentIntegration: "both",
-        targets: { cursorMcp: true },
-      },
-    };
-    expect(() => cliValidateProgram(program)).toThrow(/mcpServer\.enabled/);
+      configure: { targets: { unknownKey: true } },
+    } as CliProgram;
+    expect(() => cliValidateProgram(program)).toThrow(/not a valid target key/);
   });
 });

package/src/configure/artifacts/paths.ts

@@ -1,25 +1,13 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import type { CliProgram } from "../../core/types.ts";
-import { mcpServerId, sanitizeToolSegment } from "../../mcp/tools.ts";
+import { mcpServerId } from "../../mcp/tools.ts";
 import { displayHomePath, userHome, xdgConfigHome } from "../../paths/host.ts";
-import { skillDirNameForTarget } from "../../skill/install.ts";
-import { resolveOpenclawConfigPath } from "./mcp-openclaw.ts";
-import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
+import { skillDirName } from "../../skill/naming.ts";
 
 export interface InstallPaths {
-  cursorSkillDir: string;
-  claudeSkillDir: string;
-  codexSkillDir: string;
-  opencodeSkillDir: string;
-  openclawSkillDir: string;
-  cursorMcpPath: string;
-  claudeMcpPath: string;
-  claudeDesktopMcpPath: string;
-  opencodeMcpPath: string;
-  chatGptMcpPath: string;
-  codexConfigPath: string;
-  openclawConfigPath: string;
+  agentsSkillDir: string;
+  agentsMcpPath: string;
   mcpName: string;
   skillDirName: string;
 }
@@ -31,7 +19,7 @@ export function displayInstallPath(path: string): string {
   return displayHomePath(path);
 }
 
-/** Resolves Claude Desktop `claude_desktop_config.json` for the current OS. */
+/** Resolves Claude Desktop `claude_desktop_config.json` for the current OS (manual setup docs). */
 export function resolveClaudeDesktopMcpPath(home: string): string {
   if (process.platform === "darwin") {
     return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
@@ -48,47 +36,15 @@ export function claudeDesktopPresent(_home: string, configPath: string): boolean
   return existsSync(configPath) || existsSync(dirname(configPath));
 }
 
-/** Resolves ChatGPT desktop `chatgpt_mcp_config.json` for the current OS. */
-export function resolveChatGptMcpPath(home: string): string {
-  if (process.platform === "darwin") {
-    return join(home, "Library", "Application Support", "ChatGPT", "chatgpt_mcp_config.json");
-  }
-  if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
-    return join(appData, "OpenAI", "ChatGPT", "chatgpt_mcp_config.json");
-  }
-  return join(xdgConfigHome(home), "ChatGPT", "chatgpt_mcp_config.json");
-}
-
-/** True when ChatGPT desktop app data exists (config file or app support directory). */
-export function chatGptDesktopPresent(_home: string, configPath: string): boolean {
-  return existsSync(configPath) || existsSync(dirname(configPath));
-}
-
 /** Resolves all install artifact paths for a program root. */
 export function resolveInstallPaths(root: CliProgram): InstallPaths {
   const home = userHome();
-  const skillDirName = sanitizeToolSegment(root.key);
-  const codexSlug = skillDirNameForTarget(root.key, "codex");
-  const opencodeSlug = skillDirNameForTarget(root.key, "opencode");
-  const openclawSlug = skillDirNameForTarget(root.key, "openclaw");
-  const claudeDesktopMcpPath = resolveClaudeDesktopMcpPath(home);
-  const chatGptMcpPath = resolveChatGptMcpPath(home);
+  const dirName = skillDirName(root.key);
 
   return {
-    cursorSkillDir: join(home, ".cursor", "skills", skillDirName),
-    claudeSkillDir: join(home, ".claude", "skills", skillDirName),
-    codexSkillDir: join(home, ".codex", "skills", codexSlug),
-    opencodeSkillDir: join(home, ".config", "opencode", "skills", opencodeSlug),
-    openclawSkillDir: join(home, ".openclaw", "skills", openclawSlug),
-    cursorMcpPath: join(home, ".cursor", "mcp.json"),
-    claudeMcpPath: join(home, ".claude.json"),
-    claudeDesktopMcpPath,
-    opencodeMcpPath: resolveOpenCodeConfigPathForInstall(home),
-    chatGptMcpPath,
-    codexConfigPath: join(home, ".codex", "config.toml"),
-    openclawConfigPath: resolveOpenclawConfigPath(home),
+    agentsSkillDir: join(home, ".agents", "skills", dirName),
+    agentsMcpPath: join(home, ".agents", "mcp.json"),
     mcpName: mcpServerId(root),
-    skillDirName,
+    skillDirName: dirName,
   };
 }

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

@@ -28,8 +28,7 @@ afterEach(() => {
 
 /** Tests for resolveInstallTargetPreview. */
 describe("resolveInstallTargetPreview", () => {
-  /** Mcp app previews MCP keys for all and mcp scopes. */
-  test("mcp app previews MCP keys for all and mcp scopes", () => {
+  test("mcp app includes agentsMcp in all scope when mcpServer enabled", () => {
     const program: CliProgram = {
       key: "mcpapp",
       version: "1",
@@ -39,38 +38,36 @@ describe("resolveInstallTargetPreview", () => {
     };
     const paths = resolveInstallPaths(program);
     const preview = resolveInstallTargetPreview(program, paths);
-    expect(preview.agentIntegration).toBe("mcp");
-    expect(preview.all).not.toContain("app");
-    expect(preview.all.length).toBeGreaterThan(0);
-    expect(preview.all.every((k) => k.endsWith("Mcp") || k === "configure")).toBe(true);
+    expect(preview.all).toEqual(["agentsMcp"]);
+    expect(preview.mcp).toEqual(["agentsMcp"]);
+    expect(preview.skill).toEqual([]);
   });
 
-  /** Tests that shell app previews skill keys. */
-  test("shell app previews skill keys", () => {
+  test("skill app includes skill in all scope when enabled", () => {
     const program: CliProgram = {
       key: "cliapp",
       version: "1",
       description: "x",
+      skill: { enabled: true },
       handler: () => {},
     };
     const paths = resolveInstallPaths(program);
     const preview = resolveInstallTargetPreview(program, paths);
-    expect(preview.agentIntegration).toBe("skill");
-    expect(preview.all).not.toContain("app");
-    expect(preview.all.length).toBeGreaterThan(0);
+    expect(preview.all).toEqual(["skill"]);
+    expect(preview.skill).toEqual(["skill"]);
     expect(preview.mcp).toEqual([]);
   });
 });
 
 /** Tests for printInstallStatus json. */
 describe("printInstallStatus json", () => {
-  /** Includes agentIntegration and effective scopes. */
-  test("includes agentIntegration and effective scopes", () => {
+  test("includes effective scopes", () => {
     const program: CliProgram = {
       key: "app",
       version: "1",
       description: "x",
       mcpServer: { enabled: true },
+      skill: { enabled: true },
       handler: () => {},
     };
     const chunks: string[] = [];
@@ -82,11 +79,11 @@ describe("printInstallStatus json", () => {
     try {
       printInstallStatus(program, { json: true });
       const parsed = JSON.parse(chunks.join("")) as {
-        agentIntegration: string;
         effective: { all: string[]; mcp: string[]; skill: string[] };
       };
-      expect(parsed.agentIntegration).toBe("mcp");
-      expect(parsed.effective.all.length).toBeGreaterThan(0);
+      expect(parsed.effective.all).toEqual(["skill", "agentsMcp"]);
+      expect(parsed.effective.skill).toEqual(["skill"]);
+      expect(parsed.effective.mcp).toEqual(["agentsMcp"]);
     } finally {
       process.stdout.write = orig;
     }

package/src/configure/artifacts/status.ts

@@ -34,7 +34,6 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
   if (opts.json) {
     const preview = resolveInstallTargetPreview(root, paths);
     const json: Record<string, unknown> = {
-      agentIntegration: preview.agentIntegration,
       effective: {
         all: preview.all,
         mcp: preview.mcp,
@@ -42,14 +41,8 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
       },
     };
     if (status.app) json.app = status.app;
-    if (status.cursorSkill) json.cursorSkill = status.cursorSkill;
-    if (status.claudeSkill) json.claudeSkill = status.claudeSkill;
-    if (status.cursorMcp) json.cursorMcp = status.cursorMcp;
-    if (status.claudeMcp) json.claudeMcp = status.claudeMcp;
-    if (status.claudeDesktopMcp) json.claudeDesktopMcp = status.claudeDesktopMcp;
-    if (status.opencodeMcp) json.opencodeMcp = status.opencodeMcp;
-    if (status.codexMcp) json.codexMcp = status.codexMcp;
-    if (status.chatGptMcp) json.chatGptMcp = status.chatGptMcp;
+    if (status.skill) json.skill = status.skill;
+    if (status.agentsMcp) json.agentsMcp = status.agentsMcp;
     process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
     return;
   }
@@ -57,14 +50,8 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
   installOut(`Installed artifacts for ${root.key}:`, opts);
   const lines: [string, string | undefined][] = [
     ["app", status.app],
-    ["cursor skill", status.cursorSkill],
-    ["claude skill", status.claudeSkill],
-    ["cursor mcp", status.cursorMcp],
-    ["claude code mcp", status.claudeMcp],
-    ["claude desktop mcp", status.claudeDesktopMcp],
-    ["opencode mcp", status.opencodeMcp],
-    ["codex mcp", status.codexMcp],
-    ["chatgpt desktop mcp", status.chatGptMcp],
+    ["agent skill", status.skill],
+    [".agents mcp", status.agentsMcp],
   ];
   let any = false;
   for (const [label, value] of lines) {
@@ -79,10 +66,6 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
 
   const configStatus = appConfigStatus(root);
   if (configStatus) {
-    installOut(`  app config: ${configStatus.path}${configStatus.exists ? "" : " (missing)"}`, opts);
-    for (const req of configStatus.required) {
-      const bindingHint = req.binding && req.binding !== "missing" && req.set ? ` (${req.binding})` : "";
-      installOut(`    ${req.key}: ${req.set ? "set" : "missing"}${bindingHint}`, opts);
-    }
+    installOut(`  app config: ${configStatus}`, opts);
   }
 }

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

@@ -1,13 +1,11 @@
-import type { CliProgram, InstallAgentIntegration } from "../../core/types.ts";
+import type { CliProgram } from "../../core/types.ts";
 import type { InstallPaths } from "./paths.ts";
 import type {
   CliInstallArtifactKey,
   DetectedSnapshot,
   InstallAction,
-  InstallActionKind,
   InstalledArtifacts,
   InstallStatus,
-  InstallTargetCategory,
   TargetPlanContext,
   UninstallAction,
 } from "./target-types.ts";
@@ -15,18 +13,11 @@ import type {
 /** Shared lifecycle for one install artifact. */
 export abstract class InstallTarget {
   abstract readonly key: CliInstallArtifactKey;
-  abstract readonly actionKind: InstallActionKind;
-  abstract readonly category: InstallTargetCategory;
-
-  /** Paired MCP/skill key for agentIntegration dedupe. */
-  readonly pairedKey?: CliInstallArtifactKey;
-
-  defaultIncludedInAll(integration: InstallAgentIntegration): boolean {
-    if (this.category === "core") return true;
-    if (this.category === "mcp") {
-      return integration === "mcp" || integration === "both";
-    }
-    return integration === "skill" || integration === "both";
+  abstract readonly actionKind: import("./target-types.ts").InstallActionKind;
+  abstract readonly category: import("./target-types.ts").InstallTargetCategory;
+
+  defaultIncludedInAll(): boolean {
+    return false;
   }
 
   abstract isAvailable(root: CliProgram, paths: InstallPaths): boolean;

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

@@ -1,27 +1,12 @@
-import type {
-  CliConfigureConfig,
-  CliConfigureTargets,
-  CliProgram,
-  InstallAgentIntegration,
-  InstallTargetSpec,
-} from "../../core/types.ts";
+import type { CliConfigureConfig, CliProgram, InstallTargetSpec } from "../../core/types.ts";
 import { resolveCapabilities } from "../../runtime/capabilities.ts";
-import {
-  AGENT_PAIRS,
-  INSTALL_ARTIFACT_KEYS,
-  installTargetForKey,
-  mcpServerRequiredForArtifact,
-} from "./target-registry.ts";
+import { INSTALL_ARTIFACT_KEYS, installTargetForKey, mcpServerRequiredForArtifact } from "./target-registry.ts";
 import type { CliInstallArtifactKey, InstallPlanMode } from "./target-types.ts";
 
 export type { InstallTargetSpec, ResolvedInstallTarget } from "../../core/types.ts";
 
 export type { InstallPlanMode, InstallScope } from "./target-types.ts";
 
-export function resolveAgentIntegration(configure?: CliConfigureConfig, mcpEnabled = false): InstallAgentIntegration {
-  return configure?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
-}
-
 /** Resolves a boolean or object target spec against category defaults. */
 export function resolveInstallTargetSpec(
   spec: InstallTargetSpec | undefined,
@@ -44,56 +29,34 @@ export function resolveInstallTargetSpec(
 
 function artifactDefaults(
   key: CliInstallArtifactKey,
-  integration: InstallAgentIntegration,
-  mcpServerEnabled: boolean,
+  program?: Pick<CliProgram, "mcpServer" | "skill">,
 ): { enabled: boolean; includedInAll: boolean } {
+  if (key === "skill") {
+    const on = program?.skill?.enabled === true;
+    return { enabled: on, includedInAll: on };
+  }
+  if (key === "agentsMcp") {
+    const on = program?.mcpServer?.enabled === true;
+    return { enabled: on, includedInAll: on };
+  }
   const target = installTargetForKey(key);
-  const includedInAll = target?.defaultIncludedInAll(integration) ?? false;
-  if (!mcpServerRequiredForArtifact(key, mcpServerEnabled)) {
+  if (!mcpServerRequiredForArtifact(key, program?.mcpServer?.enabled === true)) {
     return { enabled: false, includedInAll: false };
   }
-  return { enabled: true, includedInAll };
-}
-
-function applyAgentPairDedupe(
-  out: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
-  user: CliConfigureTargets | undefined,
-  integration: InstallAgentIntegration,
-): void {
-  if (integration === "both") return;
-
-  for (const [mcpKey, skillKey] of AGENT_PAIRS) {
-    const mcp = out[mcpKey];
-    const skill = out[skillKey];
-    if (!mcp.includedInAll || !skill.includedInAll) continue;
-
-    const mcpKeyExplicit = user?.[mcpKey] !== undefined;
-    const skillKeyExplicit = user?.[skillKey] !== undefined;
-
-    if (mcpKeyExplicit && !skillKeyExplicit) continue;
-    if (skillKeyExplicit && !mcpKeyExplicit) continue;
-
-    if (integration === "mcp") {
-      out[skillKey] = { ...skill, includedInAll: false };
-    } else {
-      out[mcpKey] = { ...mcp, includedInAll: false };
-    }
-  }
+  return { enabled: true, includedInAll: target?.defaultIncludedInAll() ?? false };
 }
 
 /** Effective per-artifact gates for install.targets. */
 export function resolveEffectiveInstallTargets(
   configure?: CliConfigureConfig,
-  program?: Pick<CliProgram, "mcpServer">,
+  program?: Pick<CliProgram, "mcpServer" | "skill">,
 ): Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }> {
-  const mcpEnabled = program?.mcpServer?.enabled === true;
-  const integration = resolveAgentIntegration(configure, mcpEnabled);
   const user = configure?.targets;
   const out = {} as Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>;
   for (const key of INSTALL_ARTIFACT_KEYS) {
-    out[key] = resolveInstallTargetSpec(user?.[key], artifactDefaults(key, integration, mcpEnabled));
+    const userSpec = key === "skill" || key === "agentsMcp" ? undefined : user?.[key];
+    out[key] = resolveInstallTargetSpec(userSpec, artifactDefaults(key, program));
   }
-  applyAgentPairDedupe(out, user, integration);
   return out;
 }
 
@@ -103,7 +66,6 @@ export function mcpCategoryEnabled(root: CliProgram): boolean {
 }
 
 export interface InstallTargetPreview {
-  agentIntegration: InstallAgentIntegration;
   all: CliInstallArtifactKey[];
   mcp: CliInstallArtifactKey[];
   skill: CliInstallArtifactKey[];

package/src/configure/artifacts/target-mcp-json.ts

@@ -23,10 +23,9 @@ export interface McpJsonHostSpec {
   key: CliInstallArtifactKey;
   actionKind: InstallActionKind;
   label: string;
-  pairedSkillKey?: CliInstallArtifactKey;
   configPath: (paths: InstallPaths) => string;
-  detectedKey: keyof Pick<InstalledArtifacts, "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp">;
-  statusField: keyof Pick<InstallStatus, "cursorMcp" | "claudeMcp" | "claudeDesktopMcp" | "chatGptMcp">;
+  detectedKey: keyof Pick<InstalledArtifacts, "agentsMcp">;
+  statusField: keyof Pick<InstallStatus, "agentsMcp">;
   isAvailable: (root: CliProgram, paths: InstallPaths) => boolean;
   /** Append server name to status line (default false). */
   statusIncludesServer?: boolean;
@@ -41,7 +40,6 @@ export class McpJsonInstallTarget extends InstallTarget {
   readonly key: CliInstallArtifactKey;
   readonly actionKind: InstallActionKind;
   readonly category = "mcp" as const;
-  readonly pairedKey?: CliInstallArtifactKey;
 
   private readonly spec: McpJsonHostSpec;
 
@@ -50,7 +48,6 @@ export class McpJsonInstallTarget extends InstallTarget {
     this.spec = spec;
     this.key = spec.key;
     this.actionKind = spec.actionKind;
-    this.pairedKey = spec.pairedSkillKey;
   }
 
   isAvailable(root: CliProgram, paths: InstallPaths): boolean {

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

@@ -18,13 +18,6 @@ export const ACTION_KIND_TO_ARTIFACT: Record<InstallActionKind, CliInstallArtifa
   INSTALL_TARGETS.map((t) => [t.actionKind, t.key]),
 ) as Record<InstallActionKind, CliInstallArtifactKey>;
 
-/** Hosts with both MCP config and shell skill install targets. */
-export const AGENT_PAIRS: [CliInstallArtifactKey, CliInstallArtifactKey][] = INSTALL_TARGETS.flatMap((t) =>
-  t.category === "mcp" && t.pairedKey !== undefined
-    ? [[t.key, t.pairedKey] as [CliInstallArtifactKey, CliInstallArtifactKey]]
-    : [],
-);
-
 const targetByKey = new Map(INSTALL_TARGETS.map((t) => [t.key, t]));
 
 /** Lookup a registered install target by artifact key. */

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

@@ -6,7 +6,6 @@ import {
   type InstallPlanMode,
   type InstallScope,
   type InstallTargetPreview,
-  resolveAgentIntegration,
   resolveEffectiveInstallTargets,
   resolveInstallPlanMode,
 } from "./target-effective.ts";
@@ -30,18 +29,8 @@ export { mcpCategoryEnabled } from "./target-effective.ts";
 function emptyInstalledArtifacts(): InstalledArtifacts {
   return {
     app: false,
-    cursorSkill: false,
-    claudeSkill: false,
-    codexSkill: false,
-    opencodeSkill: false,
-    openclawSkill: false,
-    cursorMcp: false,
-    claudeMcp: false,
-    claudeDesktopMcp: false,
-    opencodeMcp: false,
-    codexMcp: false,
-    openclawMcp: false,
-    chatGptMcp: false,
+    skill: false,
+    agentsMcp: false,
   };
 }
 
@@ -75,6 +64,7 @@ export function buildDetectedSnapshot(root: CliProgram, paths: InstallPaths): De
 }
 
 function targetExplicitlyConfigured(user: CliConfigureTargets | undefined, key: CliInstallArtifactKey): boolean {
+  if (key === "skill" || key === "agentsMcp") return false;
   return user?.[key] !== undefined;
 }
 
@@ -101,6 +91,8 @@ export function isArtifactInScope(
   root: CliProgram,
   targets?: CliConfigureTargets,
 ): boolean {
+  const userTargets = targets ?? root.configure?.targets;
+
   if (mode === "uninstall-all") {
     return true;
   }
@@ -119,10 +111,10 @@ export function isArtifactInScope(
 
     let inScope = false;
     if (scope.skill) {
-      inScope = inScope || agentCategoryInScope(key, SKILL_KEYS, "skill", effective, targets, root);
+      inScope = inScope || agentCategoryInScope(key, SKILL_KEYS, "skill", effective, userTargets, root);
     }
     if (scope.mcp) {
-      inScope = inScope || agentCategoryInScope(key, MCP_KEYS, "mcp", effective, targets, root);
+      inScope = inScope || agentCategoryInScope(key, MCP_KEYS, "mcp", effective, userTargets, root);
     }
     if (scope.configure && key === "configure") {
       inScope = true;
@@ -225,13 +217,11 @@ export function detectedForArtifact(key: CliInstallArtifactKey, detected: Detect
 /** Resolved artifact keys for `--all`, `--mcp`, and `--skill` (availability-gated). */
 export function resolveInstallTargetPreview(program: CliProgram, paths: InstallPaths): InstallTargetPreview {
   const effective = resolveEffectiveInstallTargets(program.configure, program);
-  const integration = resolveAgentIntegration(program.configure, program.mcpServer?.enabled === true);
 
   const keysForScope = (scope: InstallScope, mode: InstallPlanMode): CliInstallArtifactKey[] =>
     INSTALL_ARTIFACT_KEYS.filter((key) => shouldIncludeArtifact(key, program, paths, scope, mode, effective));
 
   return {
-    agentIntegration: integration,
     all: keysForScope({ all: true }, "install-all"),
     mcp: keysForScope({ mcp: true }, "install-scoped"),
     skill: keysForScope({ skill: true }, "install-scoped"),