@mmerterden/multi-agent-pipeline 8.6.0

package/install/claude.mjs

@@ -0,0 +1,332 @@
+/**
+ * Claude Code installer.
+ *
+ * Lays down `~/.claude/{commands,scripts,agents,rules,skills}/` plus
+ * `CLAUDE.md` template, preferences template, and the secret-detection
+ * pre-commit hook in `settings.json`.
+ *
+ * Behaviour MUST stay byte-equivalent to the pre-v8.0.0 monolithic install
+ * path — install layout smoke (`smoke-install-layout.sh`) compares before/after
+ * trees on every release.
+ *
+ * @module install/claude
+ */
+
+import {
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+
+import {
+  copyDir,
+  countFiles,
+  ensureDir,
+  pruneLegacyMultiAgentSkills,
+  wipeDir,
+} from "./_common.mjs";
+import { copyExternalSkillsFiltered } from "./_platform-filter.mjs";
+import { DEV_ONLY_SCRIPTS } from "./_dev-only-files.mjs";
+
+/**
+ * @param {{
+ *   home: string,
+ *   pipelineSrc: string,
+ *   indexOnly: boolean,
+ *   useSymlinks: boolean,
+ *   platformFlag: "ios"|"android"|"all",
+ * }} ctx
+ */
+export function installClaude(ctx) {
+  const { home, pipelineSrc, indexOnly, useSymlinks, platformFlag } = ctx;
+
+  const CLAUDE_COMMANDS = join(home, ".claude", "commands");
+  const CLAUDE_AGENTS = join(home, ".claude", "agents");
+  const PREFS_PATH = join(home, ".claude", "multi-agent-preferences.json");
+  const CLAUDE_SCRIPTS = join(home, ".claude", "scripts");
+  const CLAUDE_RULES = join(home, ".claude", "rules");
+  const CLAUDE_SKILLS = join(home, ".claude", "skills");
+  const CLAUDE_SCHEMAS = join(home, ".claude", "schemas");
+  const CLAUDE_LIB = join(home, ".claude", "lib");
+
+  installCommands(pipelineSrc, CLAUDE_COMMANDS, useSymlinks);
+  installScripts(pipelineSrc, CLAUDE_SCRIPTS, useSymlinks);
+  installAgents(pipelineSrc, CLAUDE_AGENTS, useSymlinks);
+  installRules(pipelineSrc, CLAUDE_RULES, useSymlinks);
+  installSchemas(pipelineSrc, CLAUDE_SCHEMAS, useSymlinks);
+  installLib(pipelineSrc, CLAUDE_LIB, useSymlinks);
+  runPreDeployScans(pipelineSrc);
+  installSkills({ pipelineSrc, dest: CLAUDE_SKILLS, indexOnly, useSymlinks, platformFlag });
+  ensureClaudeMd(home, pipelineSrc);
+  ensurePreferences(PREFS_PATH, pipelineSrc);
+  configureSettings(home);
+
+  console.log("");
+}
+
+function installCommands(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Claude Code] Installing pipeline commands...");
+  const commandsSrc = join(pipelineSrc, "commands");
+  if (!existsSync(commandsSrc)) return;
+
+  // Wipe only our namespace dir so files renamed/removed in the source don't
+  // linger as ghost slash commands. Other namespaces under
+  // `~/.claude/commands/` are untouched.
+  const ownedCmdDir = join(dest, "multi-agent");
+  wipeDir(ownedCmdDir);
+
+  copyDir(commandsSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(commandsSrc)} files copied to ${dest}`);
+}
+
+function installScripts(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Claude Code] Installing scripts...");
+  const scriptsSrc = join(pipelineSrc, "scripts");
+  if (!existsSync(scriptsSrc)) return;
+
+  // Wipe-before-copy — scripts/ is a 100% pipeline-managed tree, so files
+  // removed upstream should not linger.
+  wipeDir(dest);
+  copyDir(scriptsSrc, dest, { exclude: DEV_ONLY_SCRIPTS, useSymlinks });
+  const scriptCount = countFiles(scriptsSrc) - DEV_ONLY_SCRIPTS.length;
+  console.log(
+    `    -> ${scriptCount} files copied to ${dest} (${DEV_ONLY_SCRIPTS.length} dev-only excluded)`,
+  );
+}
+
+function installAgents(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Claude Code] Installing agent definitions...");
+  const agentsSrc = join(pipelineSrc, "agents");
+  if (!existsSync(agentsSrc)) return;
+  wipeDir(dest);
+  copyDir(agentsSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(agentsSrc)} files copied to ${dest}`);
+}
+
+function installRules(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Claude Code] Installing rules...");
+  const rulesSrc = join(pipelineSrc, "rules");
+  if (!existsSync(rulesSrc)) return;
+  wipeDir(dest);
+  copyDir(rulesSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(rulesSrc)} files copied to ${dest}`);
+}
+
+function installSchemas(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Claude Code] Installing JSON schemas...");
+  const schemasSrc = join(pipelineSrc, "schemas");
+  if (!existsSync(schemasSrc)) return;
+  // Wipe-before-copy — schemas/ is a 100% pipeline-managed tree, so files
+  // removed upstream should not linger.
+  wipeDir(dest);
+  copyDir(schemasSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(schemasSrc)} files copied to ${dest}`);
+}
+
+function installLib(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Claude Code] Installing shell libraries...");
+  const libSrc = join(pipelineSrc, "lib");
+  if (!existsSync(libSrc)) return;
+  // Wipe-before-copy — lib/ is a 100% pipeline-managed tree.
+  wipeDir(dest);
+  copyDir(libSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(libSrc)} files copied to ${dest}`);
+}
+
+function runPreDeployScans(pipelineSrc) {
+  // Pre-deploy security scan — warn-only, never halts install on its own.
+  const scanScript = join(pipelineSrc, "scripts", "scan-skills.sh");
+  if (existsSync(scanScript)) {
+    try {
+      const out = execSync(`bash "${scanScript}" --threshold high 2>&1 | tail -3`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      console.log("  [Claude Code] Pre-deploy skill scan (warn-only):");
+      for (const line of out.split("\n").filter((l) => l.trim())) {
+        console.log(`    ${line}`);
+      }
+    } catch {
+      console.warn("  [Claude Code] Skill scan unavailable (non-fatal)");
+    }
+  }
+
+  // Pre-deploy manifest verify (v6.2.H) — warn-only.
+  const verifyScript = join(pipelineSrc, "scripts", "verify-skills.sh");
+  if (existsSync(verifyScript)) {
+    try {
+      const out = execSync(
+        `bash "${verifyScript}" --root "${join(pipelineSrc, "skills")}" 2>&1 | tail -4`,
+        { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] },
+      );
+      console.log("  [Claude Code] Skill manifest verify (v6.2.H, warn-only):");
+      for (const line of out.split("\n").filter((l) => l.trim())) {
+        console.log(`    ${line}`);
+      }
+    } catch (e) {
+      const out = e && e.stdout ? e.stdout.toString().trim() : "";
+      if (out) console.log("  [Claude Code] Skill manifest drift detected (warn-only):");
+      for (const line of out.split("\n").filter((l) => l.trim())) {
+        console.log(`    ${line}`);
+      }
+    }
+  }
+}
+
+function installSkills(opts) {
+  const { pipelineSrc, dest, indexOnly, useSymlinks, platformFlag } = opts;
+  console.log("  [Claude Code] Installing skills...");
+
+  if (indexOnly) {
+    ensureDir(dest);
+    const indexJson = join(pipelineSrc, "skills", ".skills-index.json");
+    const indexMd = join(pipelineSrc, "skills", "skills-index.md");
+    if (existsSync(indexJson)) copyFileSync(indexJson, join(dest, ".skills-index.json"));
+    if (existsSync(indexMd)) copyFileSync(indexMd, join(dest, "skills-index.md"));
+    console.log(`    -> --index-only: wrote skills-index.{json,md} to ${dest}`);
+    console.log(`    -> set prefs.global.dynamicSkillLoading=true to use (see docs)`);
+    return;
+  }
+
+  const sharedCoreSrc = join(pipelineSrc, "skills", "shared", "core");
+  const sharedExternalSrc = join(pipelineSrc, "skills", "shared", "external");
+  const figmaIosSrc = join(pipelineSrc, "skills", "figma-ios");
+  const figmaAndroidSrc = join(pipelineSrc, "skills", "figma-android");
+  const figmaCommonSrc = join(pipelineSrc, "skills", "figma-common");
+
+  let claudeSkillCount = 0;
+
+  if (existsSync(sharedCoreSrc)) {
+    copyDir(sharedCoreSrc, dest, { useSymlinks });
+    claudeSkillCount += countFiles(sharedCoreSrc);
+  }
+
+  if (existsSync(sharedExternalSrc)) {
+    const { copied, skipped } = copyExternalSkillsFiltered(sharedExternalSrc, dest, {
+      platformFlag,
+      useSymlinks,
+    });
+    claudeSkillCount += copied;
+    if (skipped > 0) {
+      console.log(
+        `    -> --platform=${platformFlag} filter skipped ${skipped} external skill dir(s)`,
+      );
+    }
+
+    // Single-standard enforcement: Claude Code invokes pipeline commands via
+    // the `/multi-agent:*` slash-command namespace, so prune duplicate skill
+    // dirs that come from the shared/external/ tree.
+    const pruned = pruneLegacyMultiAgentSkills(dest);
+    if (pruned > 0) {
+      claudeSkillCount -= pruned;
+      console.log(
+        `    -> pruned ${pruned} legacy multi-agent-* skill dirs (slash commands cover these)`,
+      );
+    }
+  }
+
+  for (const [label, src, sub] of [
+    ["figma-ios", figmaIosSrc, "figma-ios"],
+    ["figma-android", figmaAndroidSrc, "figma-android"],
+    ["figma-common", figmaCommonSrc, "figma-common"],
+  ]) {
+    if (!existsSync(src)) continue;
+    const dst = join(dest, sub);
+    copyDir(src, dst, { useSymlinks });
+    const count = countFiles(src);
+    claudeSkillCount += count;
+    console.log(`    -> ${label}: ${count} files -> ${dst}`);
+  }
+
+  console.log(`    -> ${claudeSkillCount} skill files installed to ${dest}`);
+
+  // Keep the shared skills index README in sync.
+  const sharedReadmeSrc = join(pipelineSrc, "skills", "shared", "README.md");
+  if (existsSync(sharedReadmeSrc)) {
+    const claudeReadme = join(dest, "README.md");
+    try {
+      copyFileSync(sharedReadmeSrc, claudeReadme);
+      console.log(`    -> updated ${claudeReadme}`);
+    } catch {
+      /* non-fatal */
+    }
+  }
+}
+
+function ensureClaudeMd(home, pipelineSrc) {
+  console.log("  [Claude Code] Checking CLAUDE.md template...");
+  const CLAUDE_MD = join(home, ".claude", "CLAUDE.md");
+  const templateSrc = join(pipelineSrc, "claude-md-template.md");
+  if (!existsSync(CLAUDE_MD)) {
+    if (existsSync(templateSrc)) {
+      copyFileSync(templateSrc, CLAUDE_MD);
+      console.log(`    -> Created ${CLAUDE_MD} from template`);
+    }
+  } else {
+    console.log("    -> CLAUDE.md already exists (not overwritten)");
+  }
+}
+
+function ensurePreferences(prefsPath, pipelineSrc) {
+  console.log("  [Claude Code] Checking preferences...");
+  const prefsSrc = join(pipelineSrc, "preferences-template.json");
+  if (!existsSync(prefsPath)) {
+    if (existsSync(prefsSrc)) {
+      copyFileSync(prefsSrc, prefsPath);
+      console.log(`    -> Created ${prefsPath}`);
+    }
+  } else {
+    console.log("    -> Preferences already exists (not overwritten)");
+  }
+}
+
+function configureSettings(home) {
+  console.log("  [Claude Code] Configuring hooks + context management...");
+  const SETTINGS_PATH = join(home, ".claude", "settings.json");
+  try {
+    const settings = existsSync(SETTINGS_PATH)
+      ? JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"))
+      : {};
+
+    let settingsChanged = false;
+
+    if (!settings.env) settings.env = {};
+    if (!settings.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE) {
+      settings.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = "65";
+      settingsChanged = true;
+    }
+
+    if (!settings.hooks) settings.hooks = {};
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+    const hasPreCommitHook = settings.hooks.PreToolUse.some(
+      (h) => h.matcher === "Bash(git commit:*)",
+    );
+    if (!hasPreCommitHook) {
+      settings.hooks.PreToolUse.push({
+        matcher: "Bash(git commit:*)",
+        hooks: [
+          {
+            type: "command",
+            command: "bash $HOME/.claude/scripts/pre-commit-check.sh",
+            timeout: 15,
+            statusMessage: "Scanning for secrets...",
+          },
+        ],
+      });
+      settingsChanged = true;
+    }
+
+    if (settingsChanged) {
+      writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+      console.log("    -> Added PreToolUse secret detection hook");
+      console.log("    -> Set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=65");
+    } else {
+      console.log("    -> Hooks + env already configured");
+    }
+  } catch (e) {
+    console.log(`    -> Warning: Could not configure settings.json: ${e.message}`);
+  }
+}

package/install/copilot.mjs

@@ -0,0 +1,254 @@
+/**
+ * Copilot CLI installer.
+ *
+ * Lays down `~/.copilot/{copilot-instructions.md,scripts,agents,skills}/`,
+ * including the consolidated pipeline instructions block (marker-wrapped,
+ * non-destructive merge) and the same skill set Claude Code receives.
+ *
+ * @module install/copilot
+ */
+
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "fs";
+import { join } from "path";
+
+import {
+  copyDir,
+  countFiles,
+  ensureDir,
+  wipeDir,
+} from "./_common.mjs";
+import { copyExternalSkillsFiltered } from "./_platform-filter.mjs";
+import { DEV_ONLY_SCRIPTS } from "./_dev-only-files.mjs";
+import { generateCopilotInstructions } from "./_copilot-instructions.mjs";
+
+/**
+ * @param {{
+ *   home: string,
+ *   pipelineSrc: string,
+ *   indexOnly: boolean,
+ *   useSymlinks: boolean,
+ *   platformFlag: "ios"|"android"|"all",
+ * }} ctx
+ */
+export function installCopilot(ctx) {
+  const { home, pipelineSrc, indexOnly, useSymlinks, platformFlag } = ctx;
+
+  const COPILOT_DIR = join(home, ".copilot");
+  const COPILOT_INSTRUCTIONS = join(COPILOT_DIR, "copilot-instructions.md");
+  const COPILOT_SCRIPTS = join(COPILOT_DIR, "scripts");
+  const COPILOT_AGENTS = join(COPILOT_DIR, "agents");
+  const COPILOT_SKILLS = join(COPILOT_DIR, "skills");
+  const COPILOT_SCHEMAS = join(COPILOT_DIR, "schemas");
+  const COPILOT_LIB = join(COPILOT_DIR, "lib");
+
+  console.log("  [Copilot CLI] Installing pipeline instructions...");
+  ensureDir(COPILOT_DIR);
+  writeInstructionsFile(COPILOT_INSTRUCTIONS);
+
+  installScripts(pipelineSrc, COPILOT_SCRIPTS, useSymlinks);
+  installAgents(pipelineSrc, COPILOT_AGENTS, useSymlinks);
+  installSchemas(pipelineSrc, COPILOT_SCHEMAS, useSymlinks);
+  installLib(pipelineSrc, COPILOT_LIB, useSymlinks);
+  installSkills({ pipelineSrc, dest: COPILOT_SKILLS, indexOnly, useSymlinks, platformFlag });
+}
+
+function writeInstructionsFile(path) {
+  const pipelineSection = generateCopilotInstructions();
+
+  if (!existsSync(path)) {
+    writeFileSync(path, pipelineSection + "\n");
+    console.log("    -> Created copilot-instructions.md with pipeline");
+    return;
+  }
+
+  let existing = readFileSync(path, "utf-8");
+  const marker = "# Multi-Agent Development Pipeline";
+
+  // Drift cleanup (v5.6.2): detect pre-v5.0 pipeline sections that predate
+  // the stable marker and strip them. These blocks ("## Multi-Agent Task
+  // Orchestrator", "## Instruction Sync") were written by older install
+  // scripts and now contradict the current generator output.
+  //
+  // Match strategy: end at EXPLICIT next-section markers — either the
+  // pipeline marker itself, or a known user-preserved heading. Using a
+  // generic `\n## ` sentinel is unsafe because bash code fences inside the
+  // body contain lines like `# Personal repos` which would be mistaken for
+  // markdown headings and truncate the match early.
+  const nextSectionEnd =
+    "(?=\\n## Git Identity Routing|\\n## GitHub Account Routing|\\n## Hooks & Context Management|\\n# Multi-Agent Development Pipeline|$)";
+  const orchestratorRe = new RegExp(
+    "\\n---\\n+## Multi-Agent Task Orchestrator[\\s\\S]*?" + nextSectionEnd,
+  );
+  const instructionSyncRe = new RegExp(
+    "\\n---\\n+## Instruction Sync[\\s\\S]*?" + nextSectionEnd,
+  );
+
+  let cleaned = false;
+  if (orchestratorRe.test(existing)) {
+    existing = existing.replace(orchestratorRe, "");
+    cleaned = true;
+  }
+  if (instructionSyncRe.test(existing)) {
+    existing = existing.replace(instructionSyncRe, "");
+    cleaned = true;
+  }
+
+  if (existing.includes(marker)) {
+    const before = existing.split(marker)[0].trimEnd();
+    writeFileSync(path, before + "\n\n" + pipelineSection + "\n");
+    const suffix = cleaned ? " (also scrubbed pre-v5.0 drift section)" : "";
+    console.log(`    -> Updated existing pipeline section in copilot-instructions.md${suffix}`);
+  } else {
+    writeFileSync(path, existing.trimEnd() + "\n\n" + pipelineSection + "\n");
+    console.log("    -> Appended pipeline section to copilot-instructions.md");
+  }
+}
+
+function installScripts(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Copilot CLI] Installing scripts...");
+  const scriptsSrc = join(pipelineSrc, "scripts");
+  if (!existsSync(scriptsSrc)) return;
+  wipeDir(dest);
+  copyDir(scriptsSrc, dest, { exclude: DEV_ONLY_SCRIPTS, useSymlinks });
+  const scriptCount = countFiles(scriptsSrc) - DEV_ONLY_SCRIPTS.length;
+  console.log(
+    `    -> ${scriptCount} files copied to ${dest} (${DEV_ONLY_SCRIPTS.length} dev-only excluded)`,
+  );
+}
+
+function installAgents(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Copilot CLI] Installing agent definitions...");
+  const agentsSrc = join(pipelineSrc, "agents");
+  if (!existsSync(agentsSrc)) return;
+  wipeDir(dest);
+  copyDir(agentsSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(agentsSrc)} files copied to ${dest}`);
+}
+
+function installSchemas(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Copilot CLI] Installing JSON schemas...");
+  const schemasSrc = join(pipelineSrc, "schemas");
+  if (!existsSync(schemasSrc)) return;
+  wipeDir(dest);
+  copyDir(schemasSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(schemasSrc)} files copied to ${dest}`);
+}
+
+function installLib(pipelineSrc, dest, useSymlinks) {
+  console.log("  [Copilot CLI] Installing shell libraries...");
+  const libSrc = join(pipelineSrc, "lib");
+  if (!existsSync(libSrc)) return;
+  wipeDir(dest);
+  copyDir(libSrc, dest, { useSymlinks });
+  console.log(`    -> ${countFiles(libSrc)} files copied to ${dest}`);
+}
+
+function installSkills(opts) {
+  const { pipelineSrc, dest, indexOnly, useSymlinks, platformFlag } = opts;
+  console.log("  [Copilot CLI] Installing skills...");
+
+  if (indexOnly) {
+    try {
+      mkdirSync(dest, { recursive: true });
+    } catch {
+      /* ok */
+    }
+    const indexJson = join(pipelineSrc, "skills", ".skills-index.json");
+    const indexMd = join(pipelineSrc, "skills", "skills-index.md");
+    if (existsSync(indexJson)) copyFileSync(indexJson, join(dest, ".skills-index.json"));
+    if (existsSync(indexMd)) copyFileSync(indexMd, join(dest, "skills-index.md"));
+    console.log(`    -> --index-only: wrote skills-index.{json,md} to ${dest}`);
+    console.log("");
+    return;
+  }
+
+  const sharedCoreSrc = join(pipelineSrc, "skills", "shared", "core");
+  const sharedExternalSrc = join(pipelineSrc, "skills", "shared", "external");
+  const figmaIosSrc = join(pipelineSrc, "skills", "figma-ios");
+  const figmaAndroidSrc = join(pipelineSrc, "skills", "figma-android");
+  const figmaCommonSrc = join(pipelineSrc, "skills", "figma-common");
+  let copilotSkillCount = 0;
+
+  // Wipe stale multi-agent-* skill dirs that were removed upstream.
+  if (existsSync(dest) && existsSync(sharedCoreSrc)) {
+    const sourceNames = new Set();
+    for (const entry of readdirSync(sharedCoreSrc, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name.startsWith("multi-agent")) {
+        sourceNames.add(entry.name);
+      }
+    }
+    let pruned = 0;
+    for (const entry of readdirSync(dest, { withFileTypes: true })) {
+      if (
+        entry.isDirectory() &&
+        entry.name.startsWith("multi-agent") &&
+        !sourceNames.has(entry.name)
+      ) {
+        try {
+          rmSync(join(dest, entry.name), { recursive: true, force: true });
+          pruned++;
+        } catch {
+          /* non-fatal */
+        }
+      }
+    }
+    if (pruned > 0) {
+      console.log(`    -> pruned ${pruned} stale multi-agent-* skill dir(s) (upstream removed)`);
+    }
+  }
+
+  if (existsSync(sharedCoreSrc)) {
+    copyDir(sharedCoreSrc, dest, { useSymlinks });
+    copilotSkillCount += countFiles(sharedCoreSrc);
+  }
+
+  if (existsSync(sharedExternalSrc)) {
+    const { copied, skipped } = copyExternalSkillsFiltered(sharedExternalSrc, dest, {
+      platformFlag,
+      useSymlinks,
+    });
+    copilotSkillCount += copied;
+    if (skipped > 0) {
+      console.log(
+        `    -> --platform=${platformFlag} filter skipped ${skipped} external skill dir(s)`,
+      );
+    }
+  }
+
+  for (const [label, src, sub] of [
+    ["figma-ios", figmaIosSrc, "figma-ios"],
+    ["figma-android", figmaAndroidSrc, "figma-android"],
+    ["figma-common", figmaCommonSrc, "figma-common"],
+  ]) {
+    if (!existsSync(src)) continue;
+    const dst = join(dest, sub);
+    copyDir(src, dst, { useSymlinks });
+    const count = countFiles(src);
+    copilotSkillCount += count;
+    console.log(`    -> ${label}: ${count} files -> ${dst}`);
+  }
+
+  console.log(`    -> ${copilotSkillCount} skill files installed to ${dest}`);
+
+  const sharedReadmeSrc = join(pipelineSrc, "skills", "shared", "README.md");
+  if (existsSync(sharedReadmeSrc)) {
+    const copilotReadme = join(dest, "README.md");
+    try {
+      copyFileSync(sharedReadmeSrc, copilotReadme);
+      console.log(`    -> updated ${copilotReadme}`);
+    } catch {
+      /* non-fatal */
+    }
+  }
+  console.log("");
+}
+
+export { generateCopilotInstructions };