@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/adapters/_base.mjs

@@ -0,0 +1,288 @@
+/**
+ * @file Adapter base — shared helpers for third-party AI tool adapters.
+ *
+ * Each adapter (cursor.mjs, windsurf.mjs, cline.mjs) consumes the same source
+ * tree under `pipeline/skills/` and `pipeline/rules/` and emits its own format.
+ * This module owns the shared mechanics: SKILL.md parsing, frontmatter mapping,
+ * platform glob inference, and the `<!-- multi-agent-pipeline:begin/end -->`
+ * marker pair used to scope pipeline-managed content inside user-owned files.
+ *
+ * Zero runtime deps (ADR-4). Pure ES module.
+ *
+ * @module pipeline/adapters/_base
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "fs";
+import { join, relative } from "path";
+
+/**
+ * Pipeline-managed block markers. Anything between BEGIN and END inside a
+ * user-owned file is owned by this installer and may be replaced/removed.
+ * Content outside the markers is preserved on uninstall.
+ */
+export const MARKER_BEGIN = "<!-- multi-agent-pipeline:begin -->";
+export const MARKER_END = "<!-- multi-agent-pipeline:end -->";
+
+/**
+ * Parse a YAML-ish frontmatter block from a SKILL.md file. The pipeline's
+ * frontmatter is intentionally narrow (no nested mappings inside list values,
+ * no anchors), so a regex parser is sufficient and avoids a YAML dep.
+ *
+ * @param {string} raw - file contents
+ * @returns {{ frontmatter: Record<string, string>, body: string }}
+ */
+export function parseFrontmatter(raw) {
+  const match = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/.exec(raw);
+  if (!match) return { frontmatter: {}, body: raw };
+  const [, fmBlock, body] = match;
+  const fm = {};
+  for (const line of fmBlock.split("\n")) {
+    const kv = /^([a-zA-Z][\w-]*)\s*:\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    let val = kv[2].trim();
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    fm[kv[1]] = val;
+  }
+  return { frontmatter: fm, body: body.trimStart() };
+}
+
+/**
+ * Walk a skills root and yield every SKILL.md found one directory deep. The
+ * pipeline tree is shallow on purpose (one dir per skill, body inside), so a
+ * one-level scan covers shared/core, shared/external, figma-{ios,android,common}.
+ *
+ * @param {string} skillsRoot
+ * @returns {Array<{ name: string, srcPath: string, frontmatter: Record<string, string>, body: string }>}
+ */
+export function walkSkills(skillsRoot) {
+  const out = [];
+  if (!existsSync(skillsRoot)) return out;
+  for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join(skillsRoot, entry.name, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    const raw = readFileSync(skillFile, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(raw);
+    out.push({
+      name: frontmatter.name || entry.name,
+      srcPath: skillFile,
+      frontmatter,
+      body,
+    });
+  }
+  return out;
+}
+
+/**
+ * Infer a Cursor-style globs string from a skill name. Mirrors the prefix
+ * heuristic in `install.js#classifyExternalSkill` so the two stay in sync,
+ * but returns globs instead of a coarse platform tag.
+ *
+ * Skills that don't match a known prefix get null (= no globs, = always-on
+ * eligible). The adapter decides whether null means alwaysApply or just
+ * description-only.
+ *
+ * @param {string} skillName
+ * @returns {string | null}
+ */
+export function inferGlobs(skillName) {
+  const lower = skillName.toLowerCase();
+  if (lower.startsWith("multi-agent")) return null;
+  if (
+    lower.startsWith("swiftui") ||
+    lower.startsWith("swift") ||
+    lower.startsWith("ios") ||
+    lower.startsWith("apple-") ||
+    lower === "alarmkit" ||
+    lower === "callkit-voip" ||
+    lower === "cloudkit-sync" ||
+    lower === "core-bluetooth" ||
+    lower === "core-motion" ||
+    lower === "core-nfc" ||
+    lower === "coreml" ||
+    lower === "eventkit-calendar" ||
+    lower === "healthkit" ||
+    lower === "homekit-matter" ||
+    lower === "live-activities" ||
+    lower === "mapkit-location" ||
+    lower === "musickit-audio" ||
+    lower === "passkit-wallet" ||
+    lower === "pencilkit-drawing" ||
+    lower === "permissionkit" ||
+    lower === "realitykit-ar" ||
+    lower === "speech-recognition" ||
+    lower === "storekit" ||
+    lower === "tipkit" ||
+    lower === "vision-framework" ||
+    lower === "weatherkit" ||
+    lower === "widgetkit" ||
+    lower === "natural-language" ||
+    lower === "authentication" ||
+    lower === "background-processing" ||
+    lower === "contacts-framework" ||
+    lower === "device-integrity" ||
+    lower === "debugging-instruments" ||
+    lower === "energykit" ||
+    lower === "metrickit-diagnostics" ||
+    lower === "shareplay-activities" ||
+    lower === "photos-camera-media" ||
+    lower === "push-notifications" ||
+    lower === "swiftdata" ||
+    lower === "swiftdata-pro" ||
+    lower === "app-clips" ||
+    lower === "app-intents" ||
+    lower === "app-store-changelog" ||
+    lower === "app-store-review" ||
+    lower === "app-store-optimization" ||
+    lower.startsWith("hig-") ||
+    lower.startsWith("macos-") ||
+    lower.startsWith("apple-")
+  ) {
+    return "**/*.swift";
+  }
+  if (
+    lower.startsWith("android") ||
+    lower.startsWith("kotlin") ||
+    lower.startsWith("jetpack") ||
+    lower.startsWith("compose") ||
+    lower === "room-database" ||
+    lower === "retrofit-networking" ||
+    lower === "gradle-kotlin-dsl" ||
+    lower === "play-store-review" ||
+    lower === "google-play-compliance"
+  ) {
+    return "**/*.{kt,kts}";
+  }
+  if (lower === "react-best-practices" || lower === "nextjs-app-router") return "**/*.{tsx,ts,jsx,js}";
+  if (lower === "vue-composition") return "**/*.{vue,ts,js}";
+  if (lower === "tailwind-css" || lower === "css-modern") return "**/*.{css,scss,tsx,jsx,vue,html}";
+  if (lower === "html-semantic") return "**/*.html";
+  if (lower === "typescript-patterns") return "**/*.{ts,tsx}";
+  if (lower === "python-patterns" || lower === "fastapi-pro") return "**/*.py";
+  if (lower === "nodejs-backend-patterns") return "**/*.{js,mjs,ts}";
+  return null;
+}
+
+/**
+ * Replace (or insert) a pipeline-managed block inside a user-owned file.
+ * If the file does not exist, write it with just the block. If it exists
+ * and contains a marker pair, replace between them. Otherwise, append.
+ *
+ * @param {string} filePath
+ * @param {string} blockBody - content WITHOUT the marker lines
+ * @param {object} [opts]
+ * @param {string} [opts.beforeBlockText] - content prepended ABOVE the markers when creating new file
+ */
+export function replaceManagedBlock(filePath, blockBody, opts = {}) {
+  const wrapped = `${MARKER_BEGIN}\n${blockBody.trim()}\n${MARKER_END}`;
+  if (!existsSync(filePath)) {
+    const header = opts.beforeBlockText ? `${opts.beforeBlockText.trimEnd()}\n\n` : "";
+    writeFileSync(filePath, `${header}${wrapped}\n`);
+    return "created";
+  }
+  const existing = readFileSync(filePath, "utf-8");
+  const re = new RegExp(
+    `${escapeRegex(MARKER_BEGIN)}[\\s\\S]*?${escapeRegex(MARKER_END)}`,
+    "m",
+  );
+  if (re.test(existing)) {
+    writeFileSync(filePath, existing.replace(re, wrapped));
+    return "replaced";
+  }
+  writeFileSync(filePath, `${existing.trimEnd()}\n\n${wrapped}\n`);
+  return "appended";
+}
+
+/**
+ * Remove a pipeline-managed block from a user-owned file. If the file becomes
+ * empty (or whitespace-only) after removal, the file is deleted entirely.
+ *
+ * @param {string} filePath
+ * @returns {"removed" | "removed-and-deleted-empty-file" | "missing" | "no-marker"}
+ */
+export function removeManagedBlock(filePath) {
+  if (!existsSync(filePath)) return "missing";
+  const existing = readFileSync(filePath, "utf-8");
+  const re = new RegExp(
+    `\\s*${escapeRegex(MARKER_BEGIN)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\s*`,
+    "m",
+  );
+  if (!re.test(existing)) return "no-marker";
+  const cleaned = existing.replace(re, "\n").trim();
+  if (cleaned.length === 0) {
+    rmSync(filePath, { force: true });
+    return "removed-and-deleted-empty-file";
+  }
+  writeFileSync(filePath, cleaned + "\n");
+  return "removed";
+}
+
+/**
+ * Concatenate a list of skill bodies into a single document, with each skill
+ * preceded by a heading line. Used by adapters that emit a single rules file
+ * (windsurf) instead of one-file-per-skill (cursor / cline).
+ *
+ * @param {Array<{ name: string, frontmatter: Record<string, string>, body: string }>} skills
+ * @returns {string}
+ */
+export function concatSkills(skills) {
+  const parts = [];
+  for (const skill of skills) {
+    const desc = skill.frontmatter.description || "";
+    parts.push(`## ${skill.name}`);
+    if (desc) parts.push(`> ${desc}`);
+    parts.push("");
+    parts.push(skill.body.trim());
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+
+/**
+ * Filter the multi-agent-* core skills out of a skill list. Used by tools
+ * that don't have slash-command infrastructure (cursor / windsurf / cline) —
+ * the orchestration commands aren't invocable there, so shipping them as
+ * rules just bloats context. Tools get the knowledge layer (rules + external
+ * skills) but not the dispatch layer.
+ *
+ * @template {{ name: string }} T
+ * @param {Array<T>} skills
+ * @returns {Array<T>}
+ */
+export function withoutOrchestrationSkills(skills) {
+  return skills.filter((s) => !s.name.startsWith("multi-agent"));
+}
+
+/**
+ * Ensure a directory exists. Recursive.
+ * @param {string} dir
+ */
+export function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+/**
+ * Return the relative path of `child` against `parent` for log output.
+ * @param {string} parent
+ * @param {string} child
+ */
+export function rel(parent, child) {
+  try {
+    return relative(parent, child) || child;
+  } catch {
+    return child;
+  }
+}
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/pipeline/adapters/copilot-chat.mjs

@@ -0,0 +1,158 @@
+/**
+ * @file GitHub Copilot Chat adapter — emits `.github/copilot-instructions.md`
+ * (marker-wrapped) at the project root. Optionally also writes per-skill
+ * `.github/instructions/multi-agent-*.instructions.md` files which Copilot
+ * Chat picks up as scoped instructions.
+ *
+ * Note: this is **not** the same as `--copilot` (which targets the Copilot
+ * CLI's `~/.copilot/` configuration). Copilot Chat is a different product —
+ * the IDE-side chat that lives in VS Code / GitHub.com / JetBrains, reads
+ * repo-scoped instruction files, and has no subagent dispatch. So this
+ * adapter ports the knowledge layer only, like cursor/windsurf/cline.
+ *
+ * @module pipeline/adapters/copilot-chat
+ */
+
+import { existsSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  concatSkills,
+  ensureDir,
+  inferGlobs,
+  rel,
+  removeManagedBlock,
+  replaceManagedBlock,
+  walkSkills,
+  withoutOrchestrationSkills,
+} from "./_base.mjs";
+
+const NAME = "copilot-chat";
+const MAIN_FILE = ".github/copilot-instructions.md";
+const PER_SKILL_DIR = ".github/instructions";
+const FILE_PREFIX = "multi-agent-";
+
+/**
+ * @param {{ pipelineSrc: string, target: string, platformFilter?: "all"|"ios"|"android" }} opts
+ */
+export function install({ pipelineSrc, target, platformFilter = "all" }) {
+  const githubDir = join(target, ".github");
+  ensureDir(githubDir);
+
+  const skills = collectKnowledgeSkills(pipelineSrc, platformFilter);
+  const mainPath = join(target, MAIN_FILE);
+
+  // Main file: marker-wrapped block in copilot-instructions.md.
+  const block = renderMainBlock(skills);
+  const status = replaceManagedBlock(mainPath, block);
+  console.log(
+    `    -> [copilot-chat] ${rel(target, mainPath)} ${status} (${skills.length} skills, marker-wrapped)`,
+  );
+
+  // Per-skill instruction files: each gets a scoped frontmatter so Copilot
+  // Chat applies it only when the user touches matching globs. Filename
+  // convention `<name>.instructions.md` is the GitHub Copilot Chat 2025+ format.
+  const perSkillOut = join(target, PER_SKILL_DIR);
+  ensureDir(perSkillOut);
+  let written = 0;
+  for (const skill of skills) {
+    const fileName = `${FILE_PREFIX}${skill.name}.instructions.md`;
+    const outPath = join(perSkillOut, fileName);
+    writeFileSync(outPath, renderInstructionFile(skill));
+    written++;
+  }
+  console.log(
+    `    -> [copilot-chat] ${written} per-skill instruction files in ${rel(target, perSkillOut)}`,
+  );
+}
+
+/**
+ * @param {{ target: string }} opts
+ */
+export function uninstall({ target }) {
+  const mainPath = join(target, MAIN_FILE);
+  const status = removeManagedBlock(mainPath);
+
+  const perSkillOut = join(target, PER_SKILL_DIR);
+  let removed = 0;
+  if (existsSync(perSkillOut)) {
+    for (const entry of readdirSync(perSkillOut, { withFileTypes: true })) {
+      if (!entry.isFile()) continue;
+      if (entry.name.startsWith(FILE_PREFIX) && entry.name.endsWith(".instructions.md")) {
+        rmSync(join(perSkillOut, entry.name), { force: true });
+        removed++;
+      }
+    }
+    try {
+      if (readdirSync(perSkillOut).length === 0) {
+        rmSync(perSkillOut, { recursive: true, force: true });
+      }
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  // Don't touch .github itself — user may have other CI configs there
+  return { mainStatus: status, perSkillRemoved: removed };
+}
+
+function collectKnowledgeSkills(pipelineSrc, platformFilter) {
+  const skillsRoot = join(pipelineSrc, "skills");
+  const sources = [
+    join(skillsRoot, "shared", "core"),
+    join(skillsRoot, "shared", "external"),
+    join(skillsRoot, "figma-common"),
+  ];
+  if (platformFilter === "ios" || platformFilter === "all") {
+    sources.push(join(skillsRoot, "figma-ios"));
+  }
+  if (platformFilter === "android" || platformFilter === "all") {
+    sources.push(join(skillsRoot, "figma-android"));
+  }
+  const all = [];
+  for (const src of sources) all.push(...walkSkills(src));
+
+  const knowledge = withoutOrchestrationSkills(all);
+  if (platformFilter === "all") return knowledge;
+  return knowledge.filter((s) => {
+    const globs = inferGlobs(s.name);
+    if (!globs) return true;
+    if (platformFilter === "ios") return globs.includes("swift");
+    if (platformFilter === "android") return globs.includes("kt");
+    return true;
+  });
+}
+
+/**
+ * @param {Array<{ name: string, frontmatter: Record<string,string>, body: string }>} skills
+ */
+function renderMainBlock(skills) {
+  const header = `# multi-agent-pipeline (GitHub Copilot Chat)
+
+> Installed by @mmerterden/multi-agent-pipeline. Repo-scoped instructions for
+> GitHub Copilot Chat. The 8-phase pipeline orchestration (parallel review,
+> autopilot, subagent dispatch) is **not portable** to Copilot Chat — for
+> the full pipeline, use Claude Code or Copilot CLI. What you get here:
+> the knowledge layer (rules + skills catalog) loaded automatically into
+> every Copilot Chat conversation in this repo.
+
+`;
+  return header + concatSkills(skills);
+}
+
+/**
+ * @param {{ name: string, frontmatter: Record<string,string>, body: string }} skill
+ */
+function renderInstructionFile(skill) {
+  const description = (skill.frontmatter.description || "").replace(/\n/g, " ").trim();
+  const globs = inferGlobs(skill.name);
+  const fmLines = ["---", `description: ${jsonString(description)}`];
+  if (globs) fmLines.push(`applyTo: ${jsonString(globs)}`);
+  fmLines.push("---", "");
+  return `${fmLines.join("\n")}\n# ${skill.name}\n\n${skill.body.trim()}\n`;
+}
+
+function jsonString(s) {
+  return JSON.stringify(s);
+}
+
+export default { name: NAME, install, uninstall };

package/pipeline/adapters/cursor.mjs

@@ -0,0 +1,187 @@
+/**
+ * @file Cursor adapter — emits `.cursor/rules/*.mdc` (modern, 2025+) and a
+ * legacy `.cursorrules` fallback. Pipeline orchestration commands are NOT
+ * exported as rules — Cursor has no subagent dispatch, so the 26 slash
+ * commands can't run there. What ports cleanly: rules tree (12 files) +
+ * external skills catalog (knowledge layer).
+ *
+ * Target is the project root by default (process.cwd()) since Cursor rules
+ * are repo-scoped, not user-scoped. Use --target=<path> to override.
+ *
+ * @module pipeline/adapters/cursor
+ */
+
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  concatSkills,
+  ensureDir,
+  inferGlobs,
+  rel,
+  walkSkills,
+  withoutOrchestrationSkills,
+} from "./_base.mjs";
+
+const NAME = "cursor";
+const RULES_DIR = ".cursor/rules";
+const LEGACY_FILE = ".cursorrules";
+const FILE_PREFIX = "multi-agent-";
+
+/**
+ * @param {{ pipelineSrc: string, target: string, platformFilter?: "all"|"ios"|"android" }} opts
+ */
+export function install({ pipelineSrc, target, platformFilter = "all" }) {
+  const rulesOut = join(target, RULES_DIR);
+  ensureDir(rulesOut);
+
+  const skills = collectSkills(pipelineSrc, platformFilter);
+  const knowledgeSkills = withoutOrchestrationSkills(skills);
+
+  let written = 0;
+  for (const skill of knowledgeSkills) {
+    const fileName = `${FILE_PREFIX}${skill.name}.mdc`;
+    const outPath = join(rulesOut, fileName);
+    writeFileSync(outPath, renderMdc(skill));
+    written++;
+  }
+
+  // Pipeline rules tree (TDD, security, code-review, ...) — these stay
+  // alwaysApply because they're stack-agnostic conventions.
+  const rulesSrc = join(pipelineSrc, "rules");
+  if (existsSync(rulesSrc)) {
+    for (const entry of readdirSync(rulesSrc, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const ruleName = entry.name.replace(/\.md$/, "");
+      const body = readFileSync(join(rulesSrc, entry.name), "utf-8");
+      const outPath = join(rulesOut, `${FILE_PREFIX}rule-${ruleName}.mdc`);
+      writeFileSync(
+        outPath,
+        renderRuleMdc({ name: ruleName, body, alwaysApply: true }),
+      );
+      written++;
+    }
+  }
+
+  // Legacy .cursorrules — single concatenated digest of orchestration overview
+  // + non-orchestration skills, for users on Cursor versions that don't read
+  // `.cursor/rules/*.mdc` yet. Marker-wrapped so uninstall can target it.
+  const legacyPath = join(target, LEGACY_FILE);
+  const legacyBody = renderLegacyDigest(skills);
+  writeFileSync(legacyPath, legacyBody);
+
+  console.log(
+    `    -> [cursor] ${written} rule files in ${rel(target, rulesOut)} + legacy ${LEGACY_FILE}`,
+  );
+}
+
+/**
+ * @param {{ target: string }} opts
+ */
+export function uninstall({ target }) {
+  const rulesOut = join(target, RULES_DIR);
+  let removed = 0;
+  if (existsSync(rulesOut)) {
+    for (const entry of readdirSync(rulesOut, { withFileTypes: true })) {
+      if (!entry.isFile()) continue;
+      if (entry.name.startsWith(FILE_PREFIX) && entry.name.endsWith(".mdc")) {
+        rmSync(join(rulesOut, entry.name), { force: true });
+        removed++;
+      }
+    }
+    // Drop the rules dir if it's empty after cleanup
+    try {
+      if (readdirSync(rulesOut).length === 0) rmSync(rulesOut, { recursive: true, force: true });
+    } catch {
+      /* non-fatal */
+    }
+    // And the .cursor parent if THAT is empty (we don't remove user's other Cursor configs)
+    try {
+      const cursorParent = join(target, ".cursor");
+      if (existsSync(cursorParent) && readdirSync(cursorParent).length === 0) {
+        rmSync(cursorParent, { recursive: true, force: true });
+      }
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  const legacyPath = join(target, LEGACY_FILE);
+  if (existsSync(legacyPath)) {
+    const content = readFileSync(legacyPath, "utf-8");
+    if (content.includes("multi-agent-pipeline")) {
+      rmSync(legacyPath, { force: true });
+      removed++;
+    }
+  }
+
+  return { removed };
+}
+
+function collectSkills(pipelineSrc, platformFilter) {
+  const skillsRoot = join(pipelineSrc, "skills");
+  const sources = [
+    join(skillsRoot, "shared", "core"),
+    join(skillsRoot, "shared", "external"),
+    join(skillsRoot, "figma-ios"),
+    join(skillsRoot, "figma-android"),
+    join(skillsRoot, "figma-common"),
+  ];
+  const all = [];
+  for (const src of sources) all.push(...walkSkills(src));
+
+  if (platformFilter === "all") return all;
+  return all.filter((s) => {
+    const globs = inferGlobs(s.name);
+    if (globs == null) return true; // generic / orchestration → always include
+    if (platformFilter === "ios") return globs.includes("swift");
+    if (platformFilter === "android") return globs.includes("kt");
+    return true;
+  });
+}
+
+/**
+ * @param {{ name: string, frontmatter: Record<string,string>, body: string }} skill
+ */
+function renderMdc(skill) {
+  const description = (skill.frontmatter.description || "").replace(/\n/g, " ").trim();
+  const globs = inferGlobs(skill.name);
+  const fmLines = ["---", `description: ${jsonString(description)}`];
+  if (globs) fmLines.push(`globs: ${globs}`);
+  fmLines.push(`alwaysApply: ${globs ? "false" : "false"}`);
+  fmLines.push("---", "");
+  return `${fmLines.join("\n")}\n${skill.body.trim()}\n`;
+}
+
+/**
+ * @param {{ name: string, body: string, alwaysApply: boolean }} rule
+ */
+function renderRuleMdc({ name, body, alwaysApply }) {
+  const fmLines = [
+    "---",
+    `description: ${jsonString(`multi-agent-pipeline rule: ${name}`)}`,
+    `alwaysApply: ${alwaysApply}`,
+    "---",
+    "",
+  ];
+  return `${fmLines.join("\n")}\n${body.trim()}\n`;
+}
+
+function renderLegacyDigest(skills) {
+  const knowledge = withoutOrchestrationSkills(skills);
+  const header = `# multi-agent-pipeline (Cursor legacy .cursorrules)
+
+> Installed by @mmerterden/multi-agent-pipeline.
+> The 8-phase pipeline orchestration (parallel review, autopilot, subagent
+> dispatch) is not available in Cursor — only the knowledge layer is exported
+> here. For full pipeline, use Claude Code or Copilot CLI.
+> Run \`npx @mmerterden/multi-agent-pipeline uninstall --cursor\` to remove.
+
+`;
+  return header + concatSkills(knowledge.slice(0, 30)); // cap legacy file at top 30
+}
+
+function jsonString(s) {
+  return JSON.stringify(s);
+}
+
+export default { name: NAME, install, uninstall };

package/pipeline/agents/android-architect.md

@@ -0,0 +1,42 @@
+---
+description: Android architect — evaluates design decisions, patterns, and module structure
+model: opus
+preferredModel: opus
+modelRationale: "Architecture decisions across Gradle modules, Compose stability, Hilt graphs, and migration paths require opus-level reasoning. No sonnet downgrade recommended."
+---
+
+You are a senior Android architect with deep expertise in large-scale modular Android applications.
+
+## Your Focus
+
+- Architecture patterns (MVVM, MVI, Clean Architecture)
+- Multi-module project structure with Gradle convention plugins
+- Hilt dependency injection and module boundaries
+- Jetpack Compose performance and recomposition optimization
+- Kotlin Coroutines and Flow patterns
+- Data layer design (Repository, DataSource, Room)
+- Navigation architecture (type-safe Navigation 2.8+)
+
+## When Consulted
+
+- New feature architecture decisions
+- Module extraction / refactoring
+- Dependency graph optimization
+- ViewModel and state management design
+- Migration strategy (XML Views -> Compose, RxJava -> Coroutines)
+
+## Principles
+
+- Unidirectional data flow: Event -> ViewModel -> State -> UI
+- Module boundaries follow feature domains
+- Depend on abstractions (@Provides/@Binds), not concretions
+- Compose stability: @Immutable/@Stable for recomposition control
+- Test at every layer: ViewModel (unit), Compose (UI), Repository (integration)
+- Keep Composables stateless — state lives in ViewModel
+
+## Output Format
+
+- Diagrams using ASCII or Mermaid when helpful
+- Pros/cons for each option
+- Concrete recommendation with rationale
+- Migration path if changing existing architecture