argsbarg 6.1.10 → 6.2.2

package/src/skill/install.ts

@@ -2,10 +2,11 @@ import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { CliProgram } from "../core/types.ts";
 import { userHome } from "../paths/host.ts";
-import { generateSkillBundle, type SkillTarget } from "./generate.ts";
+import { generateSkillBundle } from "./generate.ts";
 import { applySkillInstallHints } from "./hint.ts";
+import { skillDirName } from "./naming.ts";
 
-export { skillDirNameForTarget, skillFrontmatterName, skillSlug } from "./naming.ts";
+export { skillDirName } from "./naming.ts";
 
 export interface SkillInstallOpts {
   global?: boolean;
@@ -13,60 +14,39 @@ export interface SkillInstallOpts {
   dry?: boolean;
 }
 
-function resolveSkillDir(target: SkillTarget, dirName: string, global: boolean): string {
-  const home = userHome();
-  switch (target) {
-    case "cursor":
-      return join(global ? home : process.cwd(), ".cursor", "skills", dirName);
-    case "claude":
-      return join(global ? home : process.cwd(), ".claude", "skills", dirName);
-    case "codex":
-      return join(global ? home : process.cwd(), ".codex", "skills", dirName);
-    case "opencode":
-      return join(global ? home : process.cwd(), ".config", "opencode", "skills", dirName);
-    case "openclaw":
-      return join(global ? home : process.cwd(), ".openclaw", "skills", dirName);
-  }
+/** Resolved skill directory for a program (`~/.agents/skills/<key>/` or project `.agents/skills/<key>/`). */
+export function resolveAgentsSkillDir(root: CliProgram, global = true): string {
+  const base = global ? userHome() : process.cwd();
+  return join(base, ".agents", "skills", skillDirName(root.key));
 }
 
-/** Writes SKILL.md and reference.md; returns changed file paths. */
-export function cliSkillInstall(root: CliProgram, target: SkillTarget, opts: SkillInstallOpts): string[] {
-  const bundle = generateSkillBundle(root, target);
+/** Writes skill.md, SKILL.md (compatibility copy), and reference.md; returns changed file paths. */
+export function cliSkillInstall(root: CliProgram, opts: SkillInstallOpts): string[] {
+  const bundle = generateSkillBundle(root);
   const { skillMd, referenceMd } = applySkillInstallHints(root, bundle.skillMd, bundle.referenceMd);
-  const dir = resolveSkillDir(target, bundle.dirName, opts.global ?? false);
+  const dir = resolveAgentsSkillDir(root, opts.global ?? true);
   const changed: string[] = [];
 
   if (opts.rimraf && existsSync(dir) && !opts.dry) {
     rmSync(dir, { recursive: true, force: true });
   }
 
-  const skillPath = join(dir, "SKILL.md");
+  const skillPath = join(dir, "skill.md");
+  const skillCompatPath = join(dir, "SKILL.md");
   const refPath = join(dir, "reference.md");
 
   if (!opts.dry) {
     mkdirSync(dir, { recursive: true });
     writeFileSync(skillPath, skillMd, "utf8");
+    writeFileSync(skillCompatPath, skillMd, "utf8");
     writeFileSync(refPath, referenceMd, "utf8");
   }
 
-  changed.push(skillPath, refPath);
+  changed.push(skillPath, skillCompatPath, refPath);
   return changed;
 }
 
-/** Maps install action kind to skill target. */
-export function skillTargetFromActionKind(kind: string): SkillTarget | undefined {
-  switch (kind) {
-    case "cursor-skill":
-      return "cursor";
-    case "claude-skill":
-      return "claude";
-    case "codex-skill":
-      return "codex";
-    case "opencode-skill":
-      return "opencode";
-    case "openclaw-skill":
-      return "openclaw";
-    default:
-      return undefined;
-  }
+/** True when the plan action kind installs the agent skill bundle. */
+export function isAgentSkillActionKind(kind: string): boolean {
+  return kind === "agent-skill";
 }

package/src/skill/naming.ts

@@ -1,28 +1,4 @@
-/** Agent skill install targets. */
-export type SkillTarget = "cursor" | "claude" | "codex" | "opencode" | "openclaw";
-
-import { sanitizeToolSegment } from "../mcp/tools.ts";
-
-/** Kebab-case skill folder + frontmatter name for agents that require hyphen slugs. */
-export function skillSlug(programKey: string): string {
-  return programKey
-    .replace(/[^a-zA-Z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .toLowerCase();
-}
-
-/** Directory name for a skill target (underscore vs kebab conventions). */
-export function skillDirNameForTarget(programKey: string, target: SkillTarget): string {
-  if (target === "cursor" || target === "claude") {
-    return sanitizeToolSegment(programKey);
-  }
-  return skillSlug(programKey);
-}
-
-/** Frontmatter `name` for SKILL.md by target. */
-export function skillFrontmatterName(programKey: string, target: SkillTarget): string {
-  if (target === "cursor" || target === "claude") {
-    return sanitizeToolSegment(programKey);
-  }
-  return skillSlug(programKey);
+/** Skill directory and frontmatter name from program key (path-safe segment). */
+export function skillDirName(programKey: string): string {
+  return programKey.replace(/[/\\\s]/g, "_");
 }

package/src/test/integration/config.test.ts

@@ -55,7 +55,7 @@ test("MCP program.appConfig fails when required config missing", async () => {
         params: { name: "echo_env", arguments: { name: "ARGS_TEST_SECRET" } },
       },
     ],
-    { script: "examples/mcp-test.ts", env: { ARGS_TEST_SECRET: "" } },
+    { script: "src/test/mcp-integration-fixture.ts", env: { ARGS_TEST_SECRET: "" } },
   );
   const res = responses.get(13) as { result: { isError: boolean; content: { text: string }[] } };
   expect(res.result.isError).toBe(true);
@@ -73,7 +73,7 @@ test("MCP program.appConfig succeeds when env present", async () => {
         params: { name: "echo_env", arguments: { name: "ARGS_TEST_SECRET" } },
       },
     ],
-    { script: "examples/mcp-test.ts", env: { ARGS_TEST_SECRET: "sekrit" } },
+    { script: "src/test/mcp-integration-fixture.ts", env: { ARGS_TEST_SECRET: "sekrit" } },
   );
   const res = responses.get(14) as {
     result: {
@@ -105,7 +105,7 @@ test("MCP config file loads and exports vars for tool handlers", async () => {
       },
     ],
     {
-      script: "examples/mcp-test.ts",
+      script: "src/test/mcp-integration-fixture.ts",
       env: { HOME: dir, ARGS_TEST_SECRET: "present" },
     },
   );

package/src/test/integration/mcp.test.ts

@@ -446,7 +446,7 @@ test("minimal.ts mcp without opt-in fails", async () => {
 
 test("MCP resources/list includes custom resource", async () => {
   const responses = await mcpRequest([{ jsonrpc: "2.0", id: 10, method: "resources/list", params: {} }], {
-    script: "examples/mcp-test.ts",
+    script: "src/test/mcp-integration-fixture.ts",
   });
   const res = responses.get(10) as { result: { resources: { uri: string }[] } };
   const uris = res.result.resources.map((r) => r.uri);
@@ -466,7 +466,7 @@ test("MCP resources/read returns docs topic resource body", async () => {
         params: { uri: "mcp_test://docs/readme" },
       },
     ],
-    { script: "examples/mcp-test.ts" },
+    { script: "src/test/mcp-integration-fixture.ts" },
   );
   const res = responses.get(13) as { result: { contents: { text: string }[] } };
   expect(res.result.contents[0]?.text).toBe("# MCP test readme\n");
@@ -475,7 +475,7 @@ test("MCP resources/read returns docs topic resource body", async () => {
 test("MCP resources/read returns custom resource body", async () => {
   const responses = await mcpRequest(
     [{ jsonrpc: "2.0", id: 11, method: "resources/read", params: { uri: "test://hello" } }],
-    { script: "examples/mcp-test.ts" },
+    { script: "src/test/mcp-integration-fixture.ts" },
   );
   const res = responses.get(11) as { result: { contents: { text: string }[] } };
   expect(res.result.contents[0]?.text).toBe("hello resource");
@@ -484,7 +484,7 @@ test("MCP resources/read returns custom resource body", async () => {
 test("MCP resources/read unknown URI returns error", async () => {
   const responses = await mcpRequest(
     [{ jsonrpc: "2.0", id: 12, method: "resources/read", params: { uri: "missing://nope" } }],
-    { script: "examples/mcp-test.ts" },
+    { script: "src/test/mcp-integration-fixture.ts" },
   );
   const res = responses.get(12) as { error: { code: number } };
   expect(res.error.code).toBe(-32602);

package/{examples/mcp-test.ts → src/test/mcp-integration-fixture.ts}

@@ -1,14 +1,11 @@
 #!/usr/bin/env bun
 /*
-MCP test fixture for subprocess integration tests only.
+MCP integration test fixture for subprocess tests (not a public example).
 */
 
-import { Cli, CliOptionKind, type CliProgram } from "../src/index";
+import { Cli, CliOptionKind, type CliProgram } from "../index.ts";
 
 const program = {
-  key: "mcp-test",
-  version: "0.0.0-test",
-  description: "MCP integration test fixture.",
   appConfig: {
     entries: {
       argsTestSecret: {
@@ -17,23 +14,6 @@ const program = {
       },
     },
   },
-  mcpServer: {
-    enabled: true,
-    resources: [
-      {
-        uri: "test://hello",
-        name: "hello",
-        description: "Test resource.",
-        mimeType: "text/plain",
-        load: () => "hello resource",
-      },
-    ],
-  },
-  docs: {
-    topics: {
-      readme: { text: "# MCP test readme\n" },
-    },
-  },
   commands: [
     {
       key: "echo-env",
@@ -79,6 +59,24 @@ const program = {
       },
     },
   ],
+  description: "MCP integration test fixture.",
+  docs: {
+    topics: {
+      readme: { text: "# MCP test readme\n" },
+    },
+  },
+  key: "mcp-test",
+  mcpServer: {
+    enabled: true,
+    resources: [
+      {
+        uri: "test://hello",
+        name: "hello",
+        load: () => "hello resource",
+      },
+    ],
+  },
+  version: "0.0.0-test",
 } satisfies CliProgram;
 
 const cli = new Cli(program);

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

@@ -1,127 +0,0 @@
-import type { CliProgram } from "../../core/types.ts";
-import { checkCodexMcpConflict, codexMcpHasServer, mergeCodexMcpConfig, removeCodexMcpConfig } from "./mcp-codex.ts";
-import { expectedMcpEntry } from "./mcp-config.ts";
-import {
-  checkOpenclawMcpConflict,
-  mergeOpenclawMcpConfig,
-  openclawMcpHasServer,
-  removeOpenclawMcpConfig,
-} from "./mcp-openclaw.ts";
-import { displayInstallPath, type InstallPaths, userHome } from "./paths.ts";
-import { InstallTarget } from "./target-base.ts";
-import type {
-  CliInstallArtifactKey,
-  DetectedSnapshot,
-  InstallAction,
-  InstallActionKind,
-  InstalledArtifacts,
-  InstallStatus,
-  TargetPlanContext,
-  UninstallAction,
-} from "./target-types.ts";
-
-export interface McpCliHostSpec {
-  key: CliInstallArtifactKey;
-  actionKind: InstallActionKind;
-  label: string;
-  pairedSkillKey: CliInstallArtifactKey;
-  configPath: (paths: InstallPaths) => string;
-  detectedKey: "codexMcp" | "openclawMcp";
-  statusField: "codexMcp" | "openclawMcp";
-  isAvailable: (root: CliProgram, paths: InstallPaths) => boolean;
-  hasServer: (home: string, name: string) => boolean;
-  installMessage: string;
-  uninstallMessage: string;
-  merge: (home: string, name: string, entry: ReturnType<typeof expectedMcpEntry>, dry: boolean, yes: boolean) => string;
-  remove: (home: string, name: string, dry: boolean) => void;
-  preflight: (home: string, name: string, entry: ReturnType<typeof expectedMcpEntry>, yes: boolean) => string | null;
-}
-
-/** MCP host registered via an external CLI (codex, openclaw). */
-export class McpCliInstallTarget extends InstallTarget {
-  readonly key: CliInstallArtifactKey;
-  readonly actionKind: InstallActionKind;
-  readonly category = "mcp" as const;
-  readonly pairedKey: CliInstallArtifactKey;
-
-  private readonly spec: McpCliHostSpec;
-
-  constructor(spec: McpCliHostSpec) {
-    super();
-    this.spec = spec;
-    this.key = spec.key;
-    this.actionKind = spec.actionKind;
-    this.pairedKey = spec.pairedSkillKey;
-  }
-
-  isAvailable(root: CliProgram, paths: InstallPaths): boolean {
-    return this.spec.isAvailable(root, paths);
-  }
-
-  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
-    return this.spec.hasServer(userHome(), paths.mcpName);
-  }
-
-  applyDetected(paths: InstallPaths, root: CliProgram, out: InstalledArtifacts): void {
-    out[this.spec.detectedKey] = this.isDetected(paths, root);
-  }
-
-  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
-    return detected[this.spec.detectedKey] ?? false;
-  }
-
-  protected formatStatusLine(paths: InstallPaths, _root: CliProgram): string {
-    return `${displayInstallPath(this.spec.configPath(paths))} (server "${paths.mcpName}")`;
-  }
-
-  protected assignStatusLine(status: InstallStatus, line: string): void {
-    status[this.spec.statusField] = line;
-  }
-
-  preflight(ctx: TargetPlanContext): string | null {
-    const entry = expectedMcpEntry(ctx.root);
-    return this.spec.preflight(userHome(), ctx.paths.mcpName, entry, !!ctx.opts.yes);
-  }
-
-  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
-    const entry = expectedMcpEntry(ctx.root);
-    const configPath = this.spec.configPath(ctx.paths);
-    return [
-      {
-        kind: this.actionKind,
-        summary: `${this.spec.label}: ${displayInstallPath(configPath)}`,
-        message: this.spec.installMessage.replace("{name}", ctx.paths.mcpName),
-        run: () => {
-          const written = this.spec.merge(userHome(), ctx.paths.mcpName, entry, ctx.dry, !!ctx.opts.yes);
-          return [written];
-        },
-      },
-    ];
-  }
-
-  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
-    const configPath = this.spec.configPath(ctx.paths);
-    return [
-      {
-        kind: this.actionKind,
-        summary: `${this.spec.label}: ${displayInstallPath(configPath)}`,
-        message: this.spec.uninstallMessage.replace("{name}", ctx.paths.mcpName),
-        run: () => {
-          this.spec.remove(userHome(), ctx.paths.mcpName, ctx.dry);
-          return [configPath];
-        },
-      },
-    ];
-  }
-}
-
-export {
-  checkCodexMcpConflict,
-  checkOpenclawMcpConflict,
-  codexMcpHasServer,
-  mergeCodexMcpConfig,
-  mergeOpenclawMcpConfig,
-  openclawMcpHasServer,
-  removeCodexMcpConfig,
-  removeOpenclawMcpConfig,
-};

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

@@ -1,12 +0,0 @@
-import { chatGptDesktopPresent, userHome } from "../paths.ts";
-import { McpJsonInstallTarget } from "../target-mcp-json.ts";
-
-export const chatgptMcpTarget = new McpJsonInstallTarget({
-  key: "chatgptMcp",
-  actionKind: "chatgpt-desktop-mcp",
-  label: "chatgpt desktop mcp",
-  configPath: (p) => p.chatGptMcpPath,
-  detectedKey: "chatGptMcp",
-  statusField: "chatGptMcp",
-  isAvailable: (_root, paths) => chatGptDesktopPresent(userHome(), paths.chatGptMcpPath),
-});

package/src/configure/artifacts/targets/claude-code-mcp.ts

@@ -1,15 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { userHome } from "../paths.ts";
-import { McpJsonInstallTarget } from "../target-mcp-json.ts";
-
-export const claudeCodeMcpTarget = new McpJsonInstallTarget({
-  key: "claudeCodeMcp",
-  actionKind: "claude-mcp",
-  label: "claude code mcp",
-  pairedSkillKey: "claudeSkill",
-  configPath: (p) => p.claudeMcpPath,
-  detectedKey: "claudeMcp",
-  statusField: "claudeMcp",
-  isAvailable: () => existsSync(join(userHome(), ".claude")),
-});

package/src/configure/artifacts/targets/claude-desktop-mcp.ts

@@ -1,12 +0,0 @@
-import { claudeDesktopPresent, userHome } from "../paths.ts";
-import { McpJsonInstallTarget } from "../target-mcp-json.ts";
-
-export const claudeDesktopMcpTarget = new McpJsonInstallTarget({
-  key: "claudeDesktopMcp",
-  actionKind: "claude-desktop-mcp",
-  label: "claude desktop mcp",
-  configPath: (p) => p.claudeDesktopMcpPath,
-  detectedKey: "claudeDesktopMcp",
-  statusField: "claudeDesktopMcp",
-  isAvailable: (_root, paths) => claudeDesktopPresent(userHome(), paths.claudeDesktopMcpPath),
-});

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

@@ -1,16 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { userHome } from "../paths.ts";
-import { SkillInstallTarget } from "../target-skill.ts";
-
-export const claudeSkillTarget = new SkillInstallTarget({
-  key: "claudeSkill",
-  actionKind: "claude-skill",
-  label: "Claude Code",
-  uninstallPrefix: "claude skill",
-  pairedMcpKey: "claudeCodeMcp",
-  skillDir: (p) => p.claudeSkillDir,
-  detectedKey: "claudeSkill",
-  statusField: "claudeSkill",
-  isAvailable: () => existsSync(join(userHome(), ".claude")),
-});

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

@@ -1,25 +0,0 @@
-import { codexOnPath } from "../mcp-codex.ts";
-import {
-  checkCodexMcpConflict,
-  codexMcpHasServer,
-  McpCliInstallTarget,
-  mergeCodexMcpConfig,
-  removeCodexMcpConfig,
-} from "../target-mcp-cli.ts";
-
-export const codexMcpTarget = new McpCliInstallTarget({
-  key: "codexMcp",
-  actionKind: "codex-mcp",
-  label: "codex mcp",
-  pairedSkillKey: "codexSkill",
-  configPath: (p) => p.codexConfigPath,
-  detectedKey: "codexMcp",
-  statusField: "codexMcp",
-  isAvailable: () => codexOnPath(),
-  hasServer: codexMcpHasServer,
-  installMessage: 'Registering MCP server "{name}" via codex mcp add',
-  uninstallMessage: 'Removing MCP server "{name}" from Codex via codex mcp remove',
-  merge: mergeCodexMcpConfig,
-  remove: removeCodexMcpConfig,
-  preflight: checkCodexMcpConflict,
-});

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

@@ -1,14 +0,0 @@
-import { codexOnPath } from "../mcp-codex.ts";
-import { SkillInstallTarget } from "../target-skill.ts";
-
-export const codexSkillTarget = new SkillInstallTarget({
-  key: "codexSkill",
-  actionKind: "codex-skill",
-  label: "Codex",
-  uninstallPrefix: "codex skill",
-  pairedMcpKey: "codexMcp",
-  skillDir: (p) => p.codexSkillDir,
-  detectedKey: "codexSkill",
-  statusField: "codexSkill",
-  isAvailable: () => codexOnPath(),
-});

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

@@ -1,15 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { userHome } from "../paths.ts";
-import { McpJsonInstallTarget } from "../target-mcp-json.ts";
-
-export const cursorMcpTarget = new McpJsonInstallTarget({
-  key: "cursorMcp",
-  actionKind: "cursor-mcp",
-  label: "cursor mcp",
-  pairedSkillKey: "cursorSkill",
-  configPath: (p) => p.cursorMcpPath,
-  detectedKey: "cursorMcp",
-  statusField: "cursorMcp",
-  isAvailable: () => existsSync(join(userHome(), ".cursor")),
-});

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

@@ -1,16 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { userHome } from "../paths.ts";
-import { SkillInstallTarget } from "../target-skill.ts";
-
-export const cursorSkillTarget = new SkillInstallTarget({
-  key: "cursorSkill",
-  actionKind: "cursor-skill",
-  label: "Cursor",
-  uninstallPrefix: "cursor skill",
-  pairedMcpKey: "cursorMcp",
-  skillDir: (p) => p.cursorSkillDir,
-  detectedKey: "cursorSkill",
-  statusField: "cursorSkill",
-  isAvailable: () => existsSync(join(userHome(), ".cursor")),
-});

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

@@ -1,25 +0,0 @@
-import { openclawOnPath } from "../mcp-openclaw.ts";
-import {
-  checkOpenclawMcpConflict,
-  McpCliInstallTarget,
-  mergeOpenclawMcpConfig,
-  openclawMcpHasServer,
-  removeOpenclawMcpConfig,
-} from "../target-mcp-cli.ts";
-
-export const openclawMcpTarget = new McpCliInstallTarget({
-  key: "openclawMcp",
-  actionKind: "openclaw-mcp",
-  label: "openclaw mcp",
-  pairedSkillKey: "openclawSkill",
-  configPath: (p) => p.openclawConfigPath,
-  detectedKey: "openclawMcp",
-  statusField: "openclawMcp",
-  isAvailable: () => openclawOnPath(),
-  hasServer: openclawMcpHasServer,
-  installMessage: 'Registering MCP server "{name}" via openclaw mcp add',
-  uninstallMessage: 'Removing MCP server "{name}" from OpenClaw via openclaw mcp unset',
-  merge: mergeOpenclawMcpConfig,
-  remove: removeOpenclawMcpConfig,
-  preflight: checkOpenclawMcpConflict,
-});

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

@@ -1,17 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { openclawOnPath } from "../mcp-openclaw.ts";
-import { userHome } from "../paths.ts";
-import { SkillInstallTarget } from "../target-skill.ts";
-
-export const openclawSkillTarget = new SkillInstallTarget({
-  key: "openclawSkill",
-  actionKind: "openclaw-skill",
-  label: "OpenClaw",
-  uninstallPrefix: "openclaw skill",
-  pairedMcpKey: "openclawMcp",
-  skillDir: (p) => p.openclawSkillDir,
-  detectedKey: "openclawSkill",
-  statusField: "openclawSkill",
-  isAvailable: () => existsSync(join(userHome(), ".openclaw")) || openclawOnPath(),
-});

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

@@ -1,96 +0,0 @@
-import type { CliProgram } from "../../../core/types.ts";
-import {
-  checkOpenCodeMcpConflict,
-  detectOpenCodeMcpConfigPath,
-  expectedOpenCodeMcpEntry,
-  mergeOpenCodeMcpConfig,
-  opencodePresent,
-  removeOpenCodeMcpConfig,
-} from "../mcp-opencode.ts";
-import { displayInstallPath, type InstallPaths, userHome } from "../paths.ts";
-import { InstallTarget } from "../target-base.ts";
-import type {
-  DetectedSnapshot,
-  InstallAction,
-  InstalledArtifacts,
-  InstallStatus,
-  TargetPlanContext,
-  UninstallAction,
-} from "../target-types.ts";
-
-function resolveConfigPath(paths: InstallPaths, home: string): string {
-  return detectOpenCodeMcpConfigPath(home, paths.mcpName) ?? paths.opencodeMcpPath;
-}
-
-/** OpenCode MCP (top-level `mcp` key, not `mcpServers`). */
-class OpenCodeMcpInstallTarget extends InstallTarget {
-  readonly key = "opencodeMcp" as const;
-  readonly actionKind = "opencode-mcp" as const;
-  readonly category = "mcp" as const;
-  readonly pairedKey = "opencodeSkill" as const;
-
-  isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
-    return opencodePresent(userHome());
-  }
-
-  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
-    return detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) !== undefined;
-  }
-
-  applyDetected(paths: InstallPaths, root: CliProgram, out: InstalledArtifacts): void {
-    out.opencodeMcp = this.isDetected(paths, root);
-  }
-
-  protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
-    return detected.opencodeMcp;
-  }
-
-  protected formatStatusLine(paths: InstallPaths, _root: CliProgram): string {
-    const home = userHome();
-    const path = detectOpenCodeMcpConfigPath(home, paths.mcpName) ?? paths.opencodeMcpPath;
-    return `${displayInstallPath(path)} (server "${paths.mcpName}")`;
-  }
-
-  protected assignStatusLine(status: InstallStatus, line: string): void {
-    status.opencodeMcp = line;
-  }
-
-  preflight(ctx: TargetPlanContext): string | null {
-    const entry = expectedOpenCodeMcpEntry(ctx.root);
-    return checkOpenCodeMcpConflict(ctx.paths.opencodeMcpPath, ctx.paths.mcpName, entry, !!ctx.opts.yes);
-  }
-
-  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
-    const entry = expectedOpenCodeMcpEntry(ctx.root);
-    const configPath = ctx.paths.opencodeMcpPath;
-    return [
-      {
-        kind: this.actionKind,
-        summary: `opencode mcp: ${displayInstallPath(configPath)}`,
-        message: `Merging MCP server "${ctx.paths.mcpName}" into ${displayInstallPath(configPath)}`,
-        run: () => {
-          mergeOpenCodeMcpConfig(configPath, ctx.paths.mcpName, entry, ctx.dry);
-          return [configPath];
-        },
-      },
-    ];
-  }
-
-  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
-    const home = userHome();
-    const configPath = resolveConfigPath(ctx.paths, home);
-    return [
-      {
-        kind: this.actionKind,
-        summary: `opencode mcp: ${displayInstallPath(configPath)}`,
-        message: `Removing MCP server "${ctx.paths.mcpName}" from ${displayInstallPath(configPath)}`,
-        run: () => {
-          removeOpenCodeMcpConfig(configPath, ctx.paths.mcpName, ctx.dry);
-          return [configPath];
-        },
-      },
-    ];
-  }
-}
-
-export const opencodeMcpTarget = new OpenCodeMcpInstallTarget();