@every-env/compound-plugin 0.7.0 → 0.9.0

package/src/converters/{claude-to-cursor.ts → claude-to-copilot.ts}

@@ -1,43 +1,63 @@
 import { formatFrontmatter } from "../utils/frontmatter"
 import type { ClaudeAgent, ClaudeCommand, ClaudeMcpServer, ClaudePlugin } from "../types/claude"
-import type { CursorBundle, CursorCommand, CursorMcpServer, CursorRule } from "../types/cursor"
+import type {
+  CopilotAgent,
+  CopilotBundle,
+  CopilotGeneratedSkill,
+  CopilotMcpServer,
+} from "../types/copilot"
 import type { ClaudeToOpenCodeOptions } from "./claude-to-opencode"
 
-export type ClaudeToCursorOptions = ClaudeToOpenCodeOptions
+export type ClaudeToCopilotOptions = ClaudeToOpenCodeOptions
 
-export function convertClaudeToCursor(
+const COPILOT_BODY_CHAR_LIMIT = 30_000
+
+export function convertClaudeToCopilot(
   plugin: ClaudePlugin,
-  _options: ClaudeToCursorOptions,
-): CursorBundle {
-  const usedRuleNames = new Set<string>()
-  const usedCommandNames = new Set<string>()
+  _options: ClaudeToCopilotOptions,
+): CopilotBundle {
+  const usedAgentNames = new Set<string>()
+  const usedSkillNames = new Set<string>()
+
+  const agents = plugin.agents.map((agent) => convertAgent(agent, usedAgentNames))
+
+  // Reserve skill names first so generated skills (from commands) don't collide
+  const skillDirs = plugin.skills.map((skill) => {
+    usedSkillNames.add(skill.name)
+    return {
+      name: skill.name,
+      sourceDir: skill.sourceDir,
+    }
+  })
 
-  const rules = plugin.agents.map((agent) => convertAgentToRule(agent, usedRuleNames))
-  const commands = plugin.commands.map((command) => convertCommand(command, usedCommandNames))
-  const skillDirs = plugin.skills.map((skill) => ({
-    name: skill.name,
-    sourceDir: skill.sourceDir,
-  }))
+  const generatedSkills = plugin.commands.map((command) =>
+    convertCommandToSkill(command, usedSkillNames),
+  )
 
-  const mcpServers = convertMcpServers(plugin.mcpServers)
+  const mcpConfig = convertMcpServers(plugin.mcpServers)
 
   if (plugin.hooks && Object.keys(plugin.hooks.hooks).length > 0) {
-    console.warn("Warning: Cursor does not support hooks. Hooks were skipped during conversion.")
+    console.warn("Warning: Copilot does not support hooks. Hooks were skipped during conversion.")
   }
 
-  return { rules, commands, skillDirs, mcpServers }
+  return { agents, generatedSkills, skillDirs, mcpConfig }
 }
 
-function convertAgentToRule(agent: ClaudeAgent, usedNames: Set<string>): CursorRule {
+function convertAgent(agent: ClaudeAgent, usedNames: Set<string>): CopilotAgent {
   const name = uniqueName(normalizeName(agent.name), usedNames)
   const description = agent.description ?? `Converted from Claude agent ${agent.name}`
 
   const frontmatter: Record<string, unknown> = {
     description,
-    alwaysApply: false,
+    tools: ["*"],
+    infer: true,
   }
 
-  let body = transformContentForCursor(agent.body.trim())
+  if (agent.model) {
+    frontmatter.model = agent.model
+  }
+
+  let body = transformContentForCopilot(agent.body.trim())
   if (agent.capabilities && agent.capabilities.length > 0) {
     const capabilities = agent.capabilities.map((c) => `- ${c}`).join("\n")
     body = `## Capabilities\n${capabilities}\n\n${body}`.trim()
@@ -46,39 +66,44 @@ function convertAgentToRule(agent: ClaudeAgent, usedNames: Set<string>): CursorR
     body = `Instructions converted from the ${agent.name} agent.`
   }
 
+  if (body.length > COPILOT_BODY_CHAR_LIMIT) {
+    console.warn(
+      `Warning: Agent "${agent.name}" body exceeds ${COPILOT_BODY_CHAR_LIMIT} characters (${body.length}). Copilot may truncate it.`,
+    )
+  }
+
   const content = formatFrontmatter(frontmatter, body)
   return { name, content }
 }
 
-function convertCommand(command: ClaudeCommand, usedNames: Set<string>): CursorCommand {
+function convertCommandToSkill(
+  command: ClaudeCommand,
+  usedNames: Set<string>,
+): CopilotGeneratedSkill {
   const name = uniqueName(flattenCommandName(command.name), usedNames)
 
-  const sections: string[] = []
-
+  const frontmatter: Record<string, unknown> = {
+    name,
+  }
   if (command.description) {
-    sections.push(`<!-- ${command.description} -->`)
+    frontmatter.description = command.description
   }
 
+  const sections: string[] = []
+
   if (command.argumentHint) {
     sections.push(`## Arguments\n${command.argumentHint}`)
   }
 
-  const transformedBody = transformContentForCursor(command.body.trim())
+  const transformedBody = transformContentForCopilot(command.body.trim())
   sections.push(transformedBody)
 
-  const content = sections.filter(Boolean).join("\n\n").trim()
+  const body = sections.filter(Boolean).join("\n\n").trim()
+  const content = formatFrontmatter(frontmatter, body)
   return { name, content }
 }
 
-/**
- * Transform Claude Code content to Cursor-compatible content.
- *
- * 1. Task agent calls: Task agent-name(args) -> Use the agent-name skill to: args
- * 2. Slash commands: /workflows:plan -> /plan (flatten namespace)
- * 3. Path rewriting: .claude/ -> .cursor/
- * 4. Agent references: @agent-name -> the agent-name rule
- */
-export function transformContentForCursor(body: string): string {
+export function transformContentForCopilot(body: string): string {
   let result = body
 
   // 1. Transform Task agent calls
@@ -88,24 +113,25 @@ export function transformContentForCursor(body: string): string {
     return `${prefix}Use the ${skillName} skill to: ${args.trim()}`
   })
 
-  // 2. Transform slash command references (flatten namespaces)
+  // 2. Transform slash command references (replace colons with hyphens)
   const slashCommandPattern = /(?<![:\w])\/([a-z][a-z0-9_:-]*?)(?=[\s,."')\]}`]|$)/gi
   result = result.replace(slashCommandPattern, (match, commandName: string) => {
     if (commandName.includes("/")) return match
     if (["dev", "tmp", "etc", "usr", "var", "bin", "home"].includes(commandName)) return match
-    const flattened = flattenCommandName(commandName)
-    return `/${flattened}`
+    const normalized = flattenCommandName(commandName)
+    return `/${normalized}`
   })
 
-  // 3. Rewrite .claude/ paths to .cursor/
+  // 3. Rewrite .claude/ paths to .github/ and ~/.claude/ to ~/.copilot/
   result = result
-    .replace(/~\/\.claude\//g, "~/.cursor/")
-    .replace(/\.claude\//g, ".cursor/")
+    .replace(/~\/\.claude\//g, "~/.copilot/")
+    .replace(/\.claude\//g, ".github/")
 
   // 4. Transform @agent-name references
-  const agentRefPattern = /@([a-z][a-z0-9-]*-(?:agent|reviewer|researcher|analyst|specialist|oracle|sentinel|guardian|strategist))/gi
+  const agentRefPattern =
+    /@([a-z][a-z0-9-]*-(?:agent|reviewer|researcher|analyst|specialist|oracle|sentinel|guardian|strategist))/gi
   result = result.replace(agentRefPattern, (_match, agentName: string) => {
-    return `the ${normalizeName(agentName)} rule`
+    return `the ${normalizeName(agentName)} agent`
   })
 
   return result
@@ -113,29 +139,47 @@ export function transformContentForCursor(body: string): string {
 
 function convertMcpServers(
   servers?: Record<string, ClaudeMcpServer>,
-): Record<string, CursorMcpServer> | undefined {
+): Record<string, CopilotMcpServer> | undefined {
   if (!servers || Object.keys(servers).length === 0) return undefined
 
-  const result: Record<string, CursorMcpServer> = {}
+  const result: Record<string, CopilotMcpServer> = {}
   for (const [name, server] of Object.entries(servers)) {
-    const entry: CursorMcpServer = {}
+    const entry: CopilotMcpServer = {
+      type: server.command ? "local" : "sse",
+      tools: ["*"],
+    }
+
     if (server.command) {
       entry.command = server.command
       if (server.args && server.args.length > 0) entry.args = server.args
-      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
     } else if (server.url) {
       entry.url = server.url
       if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
     }
+
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = prefixEnvVars(server.env)
+    }
+
     result[name] = entry
   }
   return result
 }
 
+function prefixEnvVars(env: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith("COPILOT_MCP_")) {
+      result[key] = value
+    } else {
+      result[`COPILOT_MCP_${key}`] = value
+    }
+  }
+  return result
+}
+
 function flattenCommandName(name: string): string {
-  const colonIndex = name.lastIndexOf(":")
-  const base = colonIndex >= 0 ? name.slice(colonIndex + 1) : name
-  return normalizeName(base)
+  return normalizeName(name)
 }
 
 function normalizeName(value: string): string {

package/src/converters/claude-to-kiro.ts

@@ -0,0 +1,262 @@
+import { readFileSync, existsSync } from "fs"
+import path from "path"
+import { formatFrontmatter } from "../utils/frontmatter"
+import type { ClaudeAgent, ClaudeCommand, ClaudeMcpServer, ClaudePlugin } from "../types/claude"
+import type {
+  KiroAgent,
+  KiroAgentConfig,
+  KiroBundle,
+  KiroMcpServer,
+  KiroSkill,
+  KiroSteeringFile,
+} from "../types/kiro"
+import type { ClaudeToOpenCodeOptions } from "./claude-to-opencode"
+
+export type ClaudeToKiroOptions = ClaudeToOpenCodeOptions
+
+const KIRO_SKILL_NAME_MAX_LENGTH = 64
+const KIRO_SKILL_NAME_PATTERN = /^[a-z][a-z0-9-]*$/
+const KIRO_DESCRIPTION_MAX_LENGTH = 1024
+
+const CLAUDE_TO_KIRO_TOOLS: Record<string, string> = {
+  Bash: "shell",
+  Write: "write",
+  Read: "read",
+  Edit: "write", // NOTE: Kiro write is full-file, not surgical edit. Lossy mapping.
+  Glob: "glob",
+  Grep: "grep",
+  WebFetch: "web_fetch",
+  Task: "use_subagent",
+}
+
+export function convertClaudeToKiro(
+  plugin: ClaudePlugin,
+  _options: ClaudeToKiroOptions,
+): KiroBundle {
+  const usedSkillNames = new Set<string>()
+
+  // Pass-through skills are processed first — they're the source of truth
+  const skillDirs = plugin.skills.map((skill) => ({
+    name: skill.name,
+    sourceDir: skill.sourceDir,
+  }))
+  for (const skill of skillDirs) {
+    usedSkillNames.add(normalizeName(skill.name))
+  }
+
+  // Convert agents to Kiro custom agents
+  const agentNames = plugin.agents.map((a) => normalizeName(a.name))
+  const agents = plugin.agents.map((agent) => convertAgentToKiroAgent(agent, agentNames))
+
+  // Convert commands to skills (generated)
+  const generatedSkills = plugin.commands.map((command) =>
+    convertCommandToSkill(command, usedSkillNames, agentNames),
+  )
+
+  // Convert MCP servers (stdio only)
+  const mcpServers = convertMcpServers(plugin.mcpServers)
+
+  // Build steering files from CLAUDE.md
+  const steeringFiles = buildSteeringFiles(plugin, agentNames)
+
+  // Warn about hooks
+  if (plugin.hooks && Object.keys(plugin.hooks.hooks).length > 0) {
+    console.warn(
+      "Warning: Kiro CLI hooks use a different format (preToolUse/postToolUse inside agent configs). Hooks were skipped during conversion.",
+    )
+  }
+
+  return { agents, generatedSkills, skillDirs, steeringFiles, mcpServers }
+}
+
+function convertAgentToKiroAgent(agent: ClaudeAgent, knownAgentNames: string[]): KiroAgent {
+  const name = normalizeName(agent.name)
+  const description = sanitizeDescription(
+    agent.description ?? `Use this agent for ${agent.name} tasks`,
+  )
+
+  const config: KiroAgentConfig = {
+    name,
+    description,
+    prompt: `file://./prompts/${name}.md`,
+    tools: ["*"],
+    resources: [
+      "file://.kiro/steering/**/*.md",
+      "skill://.kiro/skills/**/SKILL.md",
+    ],
+    includeMcpJson: true,
+    welcomeMessage: `Switching to the ${name} agent. ${description}`,
+  }
+
+  let body = transformContentForKiro(agent.body.trim(), knownAgentNames)
+  if (agent.capabilities && agent.capabilities.length > 0) {
+    const capabilities = agent.capabilities.map((c) => `- ${c}`).join("\n")
+    body = `## Capabilities\n${capabilities}\n\n${body}`.trim()
+  }
+  if (body.length === 0) {
+    body = `Instructions converted from the ${agent.name} agent.`
+  }
+
+  return { name, config, promptContent: body }
+}
+
+function convertCommandToSkill(
+  command: ClaudeCommand,
+  usedNames: Set<string>,
+  knownAgentNames: string[],
+): KiroSkill {
+  const rawName = normalizeName(command.name)
+  const name = uniqueName(rawName, usedNames)
+
+  const description = sanitizeDescription(
+    command.description ?? `Converted from Claude command ${command.name}`,
+  )
+
+  const frontmatter: Record<string, unknown> = { name, description }
+
+  let body = transformContentForKiro(command.body.trim(), knownAgentNames)
+  if (body.length === 0) {
+    body = `Instructions converted from the ${command.name} command.`
+  }
+
+  const content = formatFrontmatter(frontmatter, body)
+  return { name, content }
+}
+
+/**
+ * Transform Claude Code content to Kiro-compatible content.
+ *
+ * 1. Task agent calls: Task agent-name(args) -> Use the use_subagent tool ...
+ * 2. Path rewriting: .claude/ -> .kiro/, ~/.claude/ -> ~/.kiro/
+ * 3. Slash command refs: /workflows:plan -> use the workflows-plan skill
+ * 4. Claude tool names: Bash -> shell, Read -> read, etc.
+ * 5. Agent refs: @agent-name -> the agent-name agent (only for known agent names)
+ */
+export function transformContentForKiro(body: string, knownAgentNames: string[] = []): string {
+  let result = body
+
+  // 1. Transform Task agent calls
+  const taskPattern = /^(\s*-?\s*)Task\s+([a-z][a-z0-9-]*)\(([^)]+)\)/gm
+  result = result.replace(taskPattern, (_match, prefix: string, agentName: string, args: string) => {
+    return `${prefix}Use the use_subagent tool to delegate to the ${normalizeName(agentName)} agent: ${args.trim()}`
+  })
+
+  // 2. Rewrite .claude/ paths to .kiro/ (with word-boundary-like lookbehind)
+  result = result.replace(/(?<=^|\s|["'`])~\/\.claude\//gm, "~/.kiro/")
+  result = result.replace(/(?<=^|\s|["'`])\.claude\//gm, ".kiro/")
+
+  // 3. Slash command refs: /command-name -> skill activation language
+  result = result.replace(/(?<=^|\s)`?\/([a-zA-Z][a-zA-Z0-9_:-]*)`?/gm, (_match, cmdName: string) => {
+    const skillName = normalizeName(cmdName)
+    return `the ${skillName} skill`
+  })
+
+  // 4. Claude tool names -> Kiro tool names
+  for (const [claudeTool, kiroTool] of Object.entries(CLAUDE_TO_KIRO_TOOLS)) {
+    // Match tool name references: "the X tool", "using X", "use X to"
+    const toolPattern = new RegExp(`\\b${claudeTool}\\b(?=\\s+tool|\\s+to\\s)`, "g")
+    result = result.replace(toolPattern, kiroTool)
+  }
+
+  // 5. Transform @agent-name references (only for known agent names)
+  if (knownAgentNames.length > 0) {
+    const escapedNames = knownAgentNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+    const agentRefPattern = new RegExp(`@(${escapedNames.join("|")})\\b`, "g")
+    result = result.replace(agentRefPattern, (_match, agentName: string) => {
+      return `the ${normalizeName(agentName)} agent`
+    })
+  }
+
+  return result
+}
+
+function convertMcpServers(
+  servers?: Record<string, ClaudeMcpServer>,
+): Record<string, KiroMcpServer> {
+  if (!servers || Object.keys(servers).length === 0) return {}
+
+  const result: Record<string, KiroMcpServer> = {}
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server.command) {
+      console.warn(
+        `Warning: MCP server "${name}" has no command (HTTP/SSE transport). Kiro only supports stdio. Skipping.`,
+      )
+      continue
+    }
+
+    const entry: KiroMcpServer = { command: server.command }
+    if (server.args && server.args.length > 0) entry.args = server.args
+    if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
+
+    console.log(`MCP server "${name}" will execute: ${server.command}${server.args ? " " + server.args.join(" ") : ""}`)
+    result[name] = entry
+  }
+  return result
+}
+
+function buildSteeringFiles(plugin: ClaudePlugin, knownAgentNames: string[]): KiroSteeringFile[] {
+  const claudeMdPath = path.join(plugin.root, "CLAUDE.md")
+  if (!existsSync(claudeMdPath)) return []
+
+  let content: string
+  try {
+    content = readFileSync(claudeMdPath, "utf8")
+  } catch {
+    return []
+  }
+
+  if (!content || content.trim().length === 0) return []
+
+  const transformed = transformContentForKiro(content, knownAgentNames)
+  return [{ name: "compound-engineering", content: transformed }]
+}
+
+function normalizeName(value: string): string {
+  const trimmed = value.trim()
+  if (!trimmed) return "item"
+  let normalized = trimmed
+    .toLowerCase()
+    .replace(/[\\/]+/g, "-")
+    .replace(/[:\s]+/g, "-")
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/-+/g, "-") // Collapse consecutive hyphens (Agent Skills standard)
+    .replace(/^-+|-+$/g, "")
+
+  // Enforce max length (truncate at last hyphen boundary)
+  if (normalized.length > KIRO_SKILL_NAME_MAX_LENGTH) {
+    normalized = normalized.slice(0, KIRO_SKILL_NAME_MAX_LENGTH)
+    const lastHyphen = normalized.lastIndexOf("-")
+    if (lastHyphen > 0) {
+      normalized = normalized.slice(0, lastHyphen)
+    }
+    normalized = normalized.replace(/-+$/g, "")
+  }
+
+  // Ensure name starts with a letter
+  if (normalized.length === 0 || !/^[a-z]/.test(normalized)) {
+    return "item"
+  }
+
+  return normalized
+}
+
+function sanitizeDescription(value: string, maxLength = KIRO_DESCRIPTION_MAX_LENGTH): string {
+  const normalized = value.replace(/\s+/g, " ").trim()
+  if (normalized.length <= maxLength) return normalized
+  const ellipsis = "..."
+  return normalized.slice(0, Math.max(0, maxLength - ellipsis.length)).trimEnd() + ellipsis
+}
+
+function uniqueName(base: string, used: Set<string>): string {
+  if (!used.has(base)) {
+    used.add(base)
+    return base
+  }
+  let index = 2
+  while (used.has(`${base}-${index}`)) {
+    index += 1
+  }
+  const name = `${base}-${index}`
+  used.add(name)
+  return name
+}

package/src/sync/{cursor.ts → copilot.ts}

@@ -4,19 +4,21 @@ import type { ClaudeHomeConfig } from "../parsers/claude-home"
 import type { ClaudeMcpServer } from "../types/claude"
 import { forceSymlink, isValidSkillName } from "../utils/symlink"
 
-type CursorMcpServer = {
+type CopilotMcpServer = {
+  type: string
   command?: string
   args?: string[]
   url?: string
+  tools: string[]
   env?: Record<string, string>
   headers?: Record<string, string>
 }
 
-type CursorMcpConfig = {
-  mcpServers: Record<string, CursorMcpServer>
+type CopilotMcpConfig = {
+  mcpServers: Record<string, CopilotMcpServer>
 }
 
-export async function syncToCursor(
+export async function syncToCopilot(
   config: ClaudeHomeConfig,
   outputRoot: string,
 ): Promise<void> {
@@ -33,10 +35,10 @@ export async function syncToCursor(
   }
 
   if (Object.keys(config.mcpServers).length > 0) {
-    const mcpPath = path.join(outputRoot, "mcp.json")
+    const mcpPath = path.join(outputRoot, "copilot-mcp-config.json")
     const existing = await readJsonSafe(mcpPath)
-    const converted = convertMcpForCursor(config.mcpServers)
-    const merged: CursorMcpConfig = {
+    const converted = convertMcpForCopilot(config.mcpServers)
+    const merged: CopilotMcpConfig = {
       mcpServers: {
         ...(existing.mcpServers ?? {}),
         ...converted,
@@ -46,10 +48,10 @@ export async function syncToCursor(
   }
 }
 
-async function readJsonSafe(filePath: string): Promise<Partial<CursorMcpConfig>> {
+async function readJsonSafe(filePath: string): Promise<Partial<CopilotMcpConfig>> {
   try {
     const content = await fs.readFile(filePath, "utf-8")
-    return JSON.parse(content) as Partial<CursorMcpConfig>
+    return JSON.parse(content) as Partial<CopilotMcpConfig>
   } catch (err) {
     if ((err as NodeJS.ErrnoException).code === "ENOENT") {
       return {}
@@ -58,21 +60,41 @@ async function readJsonSafe(filePath: string): Promise<Partial<CursorMcpConfig>>
   }
 }
 
-function convertMcpForCursor(
+function convertMcpForCopilot(
   servers: Record<string, ClaudeMcpServer>,
-): Record<string, CursorMcpServer> {
-  const result: Record<string, CursorMcpServer> = {}
+): Record<string, CopilotMcpServer> {
+  const result: Record<string, CopilotMcpServer> = {}
   for (const [name, server] of Object.entries(servers)) {
-    const entry: CursorMcpServer = {}
+    const entry: CopilotMcpServer = {
+      type: server.command ? "local" : "sse",
+      tools: ["*"],
+    }
+
     if (server.command) {
       entry.command = server.command
       if (server.args && server.args.length > 0) entry.args = server.args
-      if (server.env && Object.keys(server.env).length > 0) entry.env = server.env
     } else if (server.url) {
       entry.url = server.url
       if (server.headers && Object.keys(server.headers).length > 0) entry.headers = server.headers
     }
+
+    if (server.env && Object.keys(server.env).length > 0) {
+      entry.env = prefixEnvVars(server.env)
+    }
+
     result[name] = entry
   }
   return result
 }
+
+function prefixEnvVars(env: Record<string, string>): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith("COPILOT_MCP_")) {
+      result[key] = value
+    } else {
+      result[`COPILOT_MCP_${key}`] = value
+    }
+  }
+  return result
+}

package/src/targets/copilot.ts

@@ -0,0 +1,48 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, writeJson, writeText } from "../utils/files"
+import type { CopilotBundle } from "../types/copilot"
+
+export async function writeCopilotBundle(outputRoot: string, bundle: CopilotBundle): Promise<void> {
+  const paths = resolveCopilotPaths(outputRoot)
+  await ensureDir(paths.githubDir)
+
+  if (bundle.agents.length > 0) {
+    const agentsDir = path.join(paths.githubDir, "agents")
+    for (const agent of bundle.agents) {
+      await writeText(path.join(agentsDir, `${agent.name}.agent.md`), agent.content + "\n")
+    }
+  }
+
+  if (bundle.generatedSkills.length > 0) {
+    const skillsDir = path.join(paths.githubDir, "skills")
+    for (const skill of bundle.generatedSkills) {
+      await writeText(path.join(skillsDir, skill.name, "SKILL.md"), skill.content + "\n")
+    }
+  }
+
+  if (bundle.skillDirs.length > 0) {
+    const skillsDir = path.join(paths.githubDir, "skills")
+    for (const skill of bundle.skillDirs) {
+      await copyDir(skill.sourceDir, path.join(skillsDir, skill.name))
+    }
+  }
+
+  if (bundle.mcpConfig && Object.keys(bundle.mcpConfig).length > 0) {
+    const mcpPath = path.join(paths.githubDir, "copilot-mcp-config.json")
+    const backupPath = await backupFile(mcpPath)
+    if (backupPath) {
+      console.log(`Backed up existing copilot-mcp-config.json to ${backupPath}`)
+    }
+    await writeJson(mcpPath, { mcpServers: bundle.mcpConfig })
+  }
+}
+
+function resolveCopilotPaths(outputRoot: string) {
+  const base = path.basename(outputRoot)
+  // If already pointing at .github, write directly into it
+  if (base === ".github") {
+    return { githubDir: outputRoot }
+  }
+  // Otherwise nest under .github
+  return { githubDir: path.join(outputRoot, ".github") }
+}