@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/adapters/_base.mjs

@@ -1,11 +1,13 @@
 /**
- * @file Adapter base — shared helpers for third-party AI tool adapters.
+ * @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.
+ * Each adapter (cursor.mjs, copilot-chat.mjs, antigravity.mjs, codex.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, the install/uninstall
+ * file-loop factories, MCP config merging, 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.
  *
@@ -13,6 +15,7 @@
  */
 
 import {
+  cpSync,
   existsSync,
   mkdirSync,
   readFileSync,
@@ -20,7 +23,9 @@ import {
   rmSync,
   writeFileSync,
 } from "fs";
+import { homedir } from "os";
 import { join, relative } from "path";
+import { DEV_ONLY_SCRIPTS } from "../../install/_dev-only-files.mjs";
 
 /**
  * Pipeline-managed block markers. Anything between BEGIN and END inside a
@@ -55,6 +60,19 @@ export function parseFrontmatter(raw) {
   return { frontmatter: fm, body: body.trimStart() };
 }
 
+/**
+ * Default skill source dirs (relative to `pipeline/skills/`) consumed by the
+ * adapters. Order matters: it drives per-file write order and the section
+ * order inside concatenated digests.
+ */
+export const DEFAULT_SKILL_SOURCES = Object.freeze([
+  "shared/core",
+  "shared/external",
+  "figma-ios",
+  "figma-android",
+  "figma-common",
+]);
+
 /**
  * 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
@@ -181,19 +199,20 @@ export function inferGlobs(skillName) {
  * @param {string} blockBody - content WITHOUT the marker lines
  * @param {object} [opts]
  * @param {string} [opts.beforeBlockText] - content prepended ABOVE the markers when creating new file
+ * @param {{ begin: string, end: string }} [opts.markers] - alternative marker pair
+ *   for formats that can't host HTML comments (e.g. `#`-comment markers in TOML)
  */
 export function replaceManagedBlock(filePath, blockBody, opts = {}) {
-  const wrapped = `${MARKER_BEGIN}\n${blockBody.trim()}\n${MARKER_END}`;
+  const begin = opts.markers ? opts.markers.begin : MARKER_BEGIN;
+  const end = opts.markers ? opts.markers.end : MARKER_END;
+  const wrapped = `${begin}\n${blockBody.trim()}\n${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",
-  );
+  const re = new RegExp(`${escapeRegex(begin)}[\\s\\S]*?${escapeRegex(end)}`, "m");
   if (re.test(existing)) {
     writeFileSync(filePath, existing.replace(re, wrapped));
     return "replaced";
@@ -207,13 +226,17 @@ export function replaceManagedBlock(filePath, blockBody, opts = {}) {
  * empty (or whitespace-only) after removal, the file is deleted entirely.
  *
  * @param {string} filePath
+ * @param {object} [opts]
+ * @param {{ begin: string, end: string }} [opts.markers] - alternative marker pair
  * @returns {"removed" | "removed-and-deleted-empty-file" | "missing" | "no-marker"}
  */
-export function removeManagedBlock(filePath) {
+export function removeManagedBlock(filePath, opts = {}) {
+  const begin = opts.markers ? opts.markers.begin : MARKER_BEGIN;
+  const end = opts.markers ? opts.markers.end : MARKER_END;
   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*`,
+    `\\s*${escapeRegex(begin)}[\\s\\S]*?${escapeRegex(end)}\\s*`,
     "m",
   );
   if (!re.test(existing)) return "no-marker";
@@ -249,7 +272,7 @@ export function concatSkills(skills) {
 
 /**
  * Filter the multi-agent-* core skills out of a skill list. Used by tools
- * that don't have slash-command infrastructure (cursor / windsurf / cline) —
+ * 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.
@@ -262,6 +285,249 @@ export function withoutOrchestrationSkills(skills) {
   return skills.filter((s) => !s.name.startsWith("multi-agent"));
 }
 
+/**
+ * Collect every skill under `pipeline/skills/` and narrow it to the requested
+ * platform. The glob heuristic from `inferGlobs` decides platform membership:
+ * skills with no inferred globs are generic and always included.
+ *
+ * @param {string} pipelineSrc
+ * @param {"all"|"ios"|"android"} [platformFilter]
+ * @param {object} [opts]
+ * @param {string[]} [opts.sources] - source dirs relative to `pipeline/skills/`;
+ *   order drives output order (defaults to DEFAULT_SKILL_SOURCES)
+ * @returns {Array<{ name: string, srcPath: string, frontmatter: Record<string, string>, body: string }>}
+ */
+export function collectSkills(pipelineSrc, platformFilter = "all", opts = {}) {
+  const skillsRoot = join(pipelineSrc, "skills");
+  const sources = opts.sources || DEFAULT_SKILL_SOURCES;
+  const all = [];
+  for (const src of sources) all.push(...walkSkills(join(skillsRoot, ...src.split("/"))));
+  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;
+  });
+}
+
+/**
+ * Walk the pipeline rules tree (`pipeline/rules/*.md`) and yield each rule's
+ * name (filename without extension) and raw body.
+ *
+ * @param {string} pipelineSrc
+ * @returns {Array<{ name: string, body: string }>}
+ */
+export function walkRules(pipelineSrc) {
+  const rulesSrc = join(pipelineSrc, "rules");
+  const out = [];
+  if (!existsSync(rulesSrc)) return out;
+  for (const entry of readdirSync(rulesSrc, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    out.push({
+      name: entry.name.replace(/\.md$/, ""),
+      body: readFileSync(join(rulesSrc, entry.name), "utf-8"),
+    });
+  }
+  return out;
+}
+
+/**
+ * Render the AGENTS.md-style skill index block: a title, an intro quote, and
+ * one bullet per skill. Used by the adapters that ship a context file instead
+ * of per-skill rule files (antigravity, codex).
+ *
+ * @param {{ title: string, intro: string[], skills: Array<{ name: string, frontmatter: Record<string, string> }> }} opts
+ * @returns {string}
+ */
+export function renderSkillIndex({ title, intro, skills }) {
+  const parts = [title, "", ...intro, "", "## Skills (knowledge index)", ""];
+  for (const s of skills) {
+    const desc = (s.frontmatter.description || "").replace(/\s+/g, " ").trim();
+    parts.push(`- **${s.name}**${desc ? ` - ${desc}` : ""}`);
+  }
+  parts.push("");
+  return parts.join("\n");
+}
+
+/**
+ * Write one rendered file per item into `outDir` (created if missing).
+ * The shared install loop behind every per-skill / per-rule emit.
+ *
+ * @template T
+ * @param {{ outDir: string, items: T[], fileFor: (item: T) => string, render: (item: T) => string }} opts
+ * @returns {number} files written
+ */
+export function installAdapterFiles({ outDir, items, fileFor, render }) {
+  ensureDir(outDir);
+  let written = 0;
+  for (const item of items) {
+    writeFileSync(join(outDir, fileFor(item)), render(item));
+    written++;
+  }
+  return written;
+}
+
+/**
+ * Transform every pipeline persona (`pipeline/agents/*.md`) into a
+ * platform-specific agent file, plus the cross-vendor second reviewer next to
+ * `code-reviewer` (the platforms support distinct per-agent models, so a
+ * second reviewer pinned to a different vendor restores 2-model review).
+ *
+ * @param {{
+ *   pipelineSrc: string,
+ *   outDir: string,
+ *   prefix: string,
+ *   fileFor: (name: string) => string,
+ *   render: (persona: string, frontmatter: Record<string, string>, body: string, opts: object) => string,
+ *   primaryOpts?: (persona: string) => object,
+ *   crossReviewer?: object,
+ * }} opts
+ * @returns {{ agents: number, names: string[] }}
+ */
+export function installPersonaAgents({ pipelineSrc, outDir, prefix, fileFor, render, primaryOpts, crossReviewer }) {
+  ensureDir(outDir);
+  const personaDir = join(pipelineSrc, "agents");
+  const names = [];
+  if (!existsSync(personaDir)) return { agents: 0, names };
+  for (const entry of readdirSync(personaDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const persona = entry.name.replace(/\.md$/, "");
+    const { frontmatter, body } = parseFrontmatter(readFileSync(join(personaDir, entry.name), "utf-8"));
+    writeFileSync(
+      join(outDir, fileFor(persona)),
+      render(persona, frontmatter, body, primaryOpts ? primaryOpts(persona) : {}),
+    );
+    names.push(`${prefix}${persona}`);
+    if (persona === "code-reviewer" && crossReviewer) {
+      writeFileSync(join(outDir, fileFor("code-reviewer-x")), render(persona, frontmatter, body, crossReviewer));
+      names.push(`${prefix}code-reviewer-x`);
+    }
+  }
+  return { agents: names.length, names };
+}
+
+/**
+ * Remove a dir if (and only if) it is empty. Never touches user content.
+ * @param {string} dir
+ */
+export function removeDirIfEmpty(dir) {
+  try {
+    if (existsSync(dir) && readdirSync(dir).length === 0) rmSync(dir, { recursive: true, force: true });
+  } catch {
+    /* non-fatal */
+  }
+}
+
+/**
+ * Remove every `<prefix>*<suffix>` file in `dir`, then drop the dir itself if
+ * it ended up empty. The shared uninstall loop behind every per-skill /
+ * per-rule / per-agent emit.
+ *
+ * @param {string} dir
+ * @param {string} prefix
+ * @param {string} suffix
+ * @returns {number} files removed
+ */
+export function removePrefixedFiles(dir, prefix, suffix) {
+  let removed = 0;
+  if (!existsSync(dir)) return removed;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (entry.name.startsWith(prefix) && entry.name.endsWith(suffix)) {
+      rmSync(join(dir, entry.name), { force: true });
+      removed++;
+    }
+  }
+  removeDirIfEmpty(dir);
+  return removed;
+}
+
+/**
+ * Remove a single pipeline-owned file, then optionally prune its parent dir
+ * when empty.
+ *
+ * @param {string} filePath
+ * @param {string} [pruneDir]
+ * @returns {number} 1 if the file existed and was removed, else 0
+ */
+export function removeFileAndPrune(filePath, pruneDir) {
+  let removed = 0;
+  if (existsSync(filePath)) {
+    rmSync(filePath, { force: true });
+    removed = 1;
+  }
+  if (pruneDir) removeDirIfEmpty(pruneDir);
+  return removed;
+}
+
+/**
+ * Register the dev-toolkit MCP server inside a JSON MCP config, merging into
+ * the user's existing servers (never clobbering them). `rootKey` follows the
+ * platform schema: `mcpServers` (Cursor, Antigravity) or `servers` (VS Code).
+ *
+ * @param {string} mcpPath
+ * @param {object} [opts]
+ * @param {string} [opts.rootKey]
+ * @returns {"created" | "merged" | "skipped"}
+ */
+export function mergeMcpJson(mcpPath, opts = {}) {
+  const rootKey = opts.rootKey || "mcpServers";
+  const entry = { command: "npx", args: ["-y", "@mmerterden/dev-toolkit-mcp"] };
+  ensureDir(join(mcpPath, ".."));
+  if (!existsSync(mcpPath)) {
+    writeFileSync(mcpPath, JSON.stringify({ [rootKey]: { "dev-toolkit": entry } }, null, 2) + "\n");
+    return "created";
+  }
+  let cfg;
+  try {
+    cfg = JSON.parse(readFileSync(mcpPath, "utf-8"));
+  } catch {
+    return "skipped";
+  }
+  cfg[rootKey] = cfg[rootKey] || {};
+  cfg[rootKey]["dev-toolkit"] = entry;
+  writeFileSync(mcpPath, JSON.stringify(cfg, null, 2) + "\n");
+  return "merged";
+}
+
+/**
+ * Remove only OUR dev-toolkit entry from a JSON MCP config; the user's other
+ * servers (and the file) survive. The file is deleted only when it held
+ * nothing but our entry.
+ *
+ * @param {string} mcpPath
+ * @param {object} [opts]
+ * @param {string} [opts.rootKey]
+ */
+export function unmergeMcpJson(mcpPath, opts = {}) {
+  const rootKey = opts.rootKey || "mcpServers";
+  if (!existsSync(mcpPath)) return;
+  let cfg;
+  try {
+    cfg = JSON.parse(readFileSync(mcpPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (cfg[rootKey] && cfg[rootKey]["dev-toolkit"]) {
+    delete cfg[rootKey]["dev-toolkit"];
+    if (Object.keys(cfg[rootKey]).length === 0) {
+      rmSync(mcpPath, { force: true });
+      return;
+    }
+    writeFileSync(mcpPath, JSON.stringify(cfg, null, 2) + "\n");
+  }
+}
+
+/**
+ * JSON-quote a frontmatter value (descriptions may contain `:` or quotes).
+ * @param {string} s
+ */
+export function jsonString(s) {
+  return JSON.stringify(s);
+}
+
 /**
  * Ensure a directory exists. Recursive.
  * @param {string} dir
@@ -286,3 +552,89 @@ export function rel(parent, child) {
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
+/**
+ * Cross-vendor reviewer model lineup per adapter platform. The pipeline's value
+ * is multi-model review (Claude Code = Opus + Sonnet; Copilot CLI adds GPT-5.4).
+ * The adapter platforms support distinct per-agent models, so we emit a SECOND
+ * reviewer agent pinned to a different vendor to restore cross-model diversity.
+ *
+ * Model strings drift as platforms ship new versions - treat this like
+ * cost-table.json and update it when the platforms' pickers change. Verified
+ * mid-2026 against each platform's model docs.
+ *
+ * Cursor: per-agent `model:` takes a model ID; the exact Claude slug is not
+ * published (docs only give `gpt-5.5` / `composer-2`), so the PRIMARY reviewer
+ * stays `inherit` (the user's selected model, usually Claude) and the SECONDARY
+ * pins `gpt-5.5` - that yields two vendors without guessing the Claude slug.
+ * Copilot Chat: frontmatter `model:` takes the picker LABEL verbatim (confirmed).
+ * Antigravity: model is chosen in the side-panel UI, not a file - so its
+ * workflow only NAMES the recommended diverse pair; it cannot pin them.
+ */
+export const REVIEWER_MODELS = Object.freeze({
+  cursor: { primary: "inherit", crossModel: "gpt-5.5" },
+  copilotChat: { primary: "Claude Opus 4.8", crossModel: "GPT-5.5" },
+  antigravity: { primary: "Gemini 3 Pro", crossModel: "Claude Opus 4.6" },
+  codex: { primary: "GPT-5.5-Codex", crossModel: "Claude Opus 4.8" },
+});
+
+/**
+ * Shared cross-platform runtime root. The non-native adapters (Cursor,
+ * Antigravity, VS Code Copilot Chat) have no user-global skills dir like
+ * `~/.claude` / `~/.copilot`, so the pipeline's deterministic-gate scripts are
+ * installed once here and the emitted agents/commands reference them by
+ * absolute path. This is what lets the gates actually EXECUTE on those
+ * platforms instead of degrading to advisory.
+ */
+export function sharedRuntimeRoot() {
+  return join(homedir(), ".multi-agent");
+}
+
+/**
+ * Copy scripts/ + lib/ + schemas/ into the shared runtime root, excluding
+ * dev-only files (the figma scrub map, the personal-data scanners). Idempotent.
+ * @param {string} pipelineSrc
+ * @returns {{ root: string, trees: string[] }}
+ */
+export function installSharedRuntime(pipelineSrc) {
+  const root = sharedRuntimeRoot();
+  const trees = [];
+  for (const sub of ["scripts", "lib", "schemas"]) {
+    const src = join(pipelineSrc, sub);
+    if (!existsSync(src)) continue;
+    const dest = join(root, sub);
+    ensureDir(dest);
+    cpSync(src, dest, {
+      recursive: true,
+      // Never copy a dev-only / PII-bearing file into the shared runtime.
+      filter: (s) => !DEV_ONLY_SCRIPTS.includes(s.split(/[\\/]/).pop()),
+    });
+    trees.push(sub);
+  }
+  return { root, trees };
+}
+
+/**
+ * Remove the shared runtime root. The tree is 100% pipeline-owned, so a full
+ * recursive remove is safe.
+ * @returns {boolean} true if anything was removed
+ */
+export function uninstallSharedRuntime() {
+  const root = sharedRuntimeRoot();
+  if (!existsSync(root)) return false;
+  rmSync(root, { recursive: true, force: true });
+  return true;
+}
+
+/**
+ * Rewrite logical `pipeline/scripts/...` and `pipeline/lib/...` references in an
+ * emitted agent/command/workflow body to the absolute shared-runtime path, so
+ * they resolve from any working directory on the adapter platforms.
+ * @param {string} body
+ * @returns {string}
+ */
+export function rewriteScriptRefs(body) {
+  return String(body)
+    .replace(/pipeline\/scripts\//g, "$HOME/.multi-agent/scripts/")
+    .replace(/pipeline\/lib\//g, "$HOME/.multi-agent/lib/");
+}

package/pipeline/adapters/antigravity.mjs

@@ -0,0 +1,140 @@
+/**
+ * @file Google Antigravity adapter  -  the Gemini CLI successor (Gemini CLI
+ * consumer support ends 2026-06-18). Antigravity shares the `.gemini/` lineage
+ * but its subagents are ORCHESTRATOR-spawned, not file-declared, so the pipeline
+ * orchestration is encoded as a saved WORKFLOW prompt plus standing RULES rather
+ * than per-role agent files (contrast cursor-orchestration.mjs).
+ *
+ * Emits (project-scoped, target = repo root):
+ *   .agent/rules/multi-agent-*.md    standing pipeline conventions (rules tree)
+ *   .agent/workflows/multi-agent.md  the 8-phase orchestration as a saved prompt
+ *   AGENTS.md                        marker-wrapped context block (rules + skill
+ *                                    index); Antigravity reads AGENTS.md/GEMINI.md
+ *   .agent/mcp_config.json           dev-toolkit MCP registration
+ *
+ * NOTE: some Antigravity paths are community-documented, not yet in official
+ * docs (flagged in the install log). `.agent/rules` + `.agent/workflows` +
+ * AGENTS.md + mcp_config.json are the best-known conventions as of 2026-05; the
+ * emitted workflow tells the user to confirm placement against current docs.
+ *
+ * @module pipeline/adapters/antigravity
+ */
+
+import { writeFileSync } from "fs";
+import { join } from "path";
+import {
+  collectSkills,
+  ensureDir,
+  installAdapterFiles,
+  installSharedRuntime,
+  mergeMcpJson,
+  removeFileAndPrune,
+  removeManagedBlock,
+  removePrefixedFiles,
+  renderSkillIndex,
+  replaceManagedBlock,
+  rewriteScriptRefs,
+  uninstallSharedRuntime,
+  unmergeMcpJson,
+  walkRules,
+  withoutOrchestrationSkills,
+} from "./_base.mjs";
+
+const NAME = "antigravity";
+const RULE_PREFIX = "multi-agent-";
+
+/**
+ * @param {{ pipelineSrc: string, target: string, platformFilter?: "all"|"ios"|"android" }} opts
+ */
+export function install({ pipelineSrc, target, platformFilter = "all" }) {
+  // 1. Rules tree -> .agent/rules/
+  const rules = installAdapterFiles({
+    outDir: join(target, ".agent", "rules"),
+    items: walkRules(pipelineSrc),
+    fileFor: (rule) => `${RULE_PREFIX}${rule.name}.md`,
+    render: (rule) => `${rule.body.trim()}\n`,
+  });
+
+  // 2. Orchestration workflow.
+  const wfOut = join(target, ".agent", "workflows");
+  ensureDir(wfOut);
+  writeFileSync(join(wfOut, "multi-agent.md"), rewriteScriptRefs(ORCHESTRATION_WORKFLOW));
+
+  // 3. AGENTS.md context block (rules already in .agent/rules; here we add a
+  //    skill index so the agent knows what reference skills exist).
+  const skills = withoutOrchestrationSkills(collectSkills(pipelineSrc, platformFilter));
+  const ctxAction = replaceManagedBlock(join(target, "AGENTS.md"), renderContext(skills));
+
+  // 4. MCP.
+  const mcp = mergeMcpJson(join(target, ".agent", "mcp_config.json"));
+
+  // 5. Shared runtime so the workflow's gate-script references resolve + run.
+  installSharedRuntime(pipelineSrc);
+
+  console.log(
+    `    -> [antigravity] ${rules} rules + workflow + AGENTS.md (${ctxAction}) + mcp_config.json (${mcp})`,
+  );
+  console.log(
+    "    -> [antigravity] NOTE: .agent/ paths are community-documented; confirm against current Antigravity docs.",
+  );
+}
+
+/**
+ * @param {{ target: string }} opts
+ */
+export function uninstall({ target }) {
+  let removed = removePrefixedFiles(join(target, ".agent", "rules"), RULE_PREFIX, ".md");
+  const wfDir = join(target, ".agent", "workflows");
+  removed += removeFileAndPrune(join(wfDir, "multi-agent.md"), wfDir);
+  removeManagedBlock(join(target, "AGENTS.md"));
+  unmergeMcpJson(join(target, ".agent", "mcp_config.json"));
+  if (uninstallSharedRuntime()) removed++;
+  return { removed };
+}
+
+function renderContext(skills) {
+  return renderSkillIndex({
+    title: "# multi-agent-pipeline (Antigravity)",
+    intro: [
+      "> Installed by @mmerterden/multi-agent-pipeline. Standing rules live in",
+      "> `.agent/rules/`; the orchestration runs via `.agent/workflows/multi-agent.md`.",
+      "> Below is the reference skill index. Remove with",
+      "> `npx @mmerterden/multi-agent-pipeline uninstall --antigravity`.",
+    ],
+    skills,
+  });
+}
+
+const ORCHESTRATION_WORKFLOW = `# /multi-agent  -  run the pipeline in Antigravity
+
+> Installed by @mmerterden/multi-agent-pipeline. Antigravity spawns subagents
+> from your goal (they are not file-declared), so this workflow encodes the
+> 8-phase orchestration as a prompt. Standing conventions are in
+> \`.agent/rules/\`. Pickers/approvals follow refs/picker-contract.md (use
+> Antigravity's approval UI or a numbered
+> prompt). The dev-toolkit MCP server is registered in \`.agent/mcp_config.json\`.
+>
+> GATE SCRIPTS: the deterministic-gate scripts are installed to a shared
+> \`$HOME/.multi-agent/scripts/\` runtime (evidence-gate.mjs, classify-intent.sh,
+> learnings-ledger.mjs, validate-triage.mjs, pre-commit-check.sh, ...). Invoke
+> them by that absolute path. Unlike Claude Code there is no PreToolUse hook
+> forcing them, so run them as explicit workflow steps (workflow-enforced, not
+> OS-blocked).
+
+Input: a Jira id, GitHub issue, repo#N, or free-text task.
+
+Run these phases in order, obeying every file under \`.agent/rules/\`:
+
+0. **Init** - detect stack, resolve branch (\`bugfix/…\` / \`feature/…\`), confirm scope.
+1. **Analysis** - explore the codebase (spawn a read-only investigator subagent); produce a structured analysis: stack, touchedAreas[], risks[], summary.
+2. **Planning** - draft the task breakdown; present it and ask the user to Approve / Cancel / edit (picker-contract). Loop on edits until approved.
+3. **Dev** - implement TDD-first (test -> code -> build), following the rules.
+4. **Review** - run review in parallel. For cross-model coverage, spawn TWO parallel code-review agents in the Agent Manager and set each to a DIFFERENT model via the side-panel dropdown (recommended pair: Gemini 3 Pro + Claude Opus 4.6) - Antigravity selects an agent's model in the UI, not a file, so this is a manual two-agent setup. Add the stack architect (iOS / Android / backend) and a security pass when auth/secrets are touched. Merge findings, triage (accept / defer / reject), record the consensus block (same-model agreement on judgment calls = unverified), fix accepted blocking/important items, re-review.
+5. **Test** - offer an interactive test pass (picker); use the dev-toolkit MCP server for simulator / emulator / web checks.
+6. **Commit** - \`{type}(scope): description\`; never auto-close issues; PR uses \`Ref: #N\`.
+7. **Report** - summarize changes, per-reviewer consensus, and cost.
+
+No "AI / generated by" in code or commits. Attribute each finding to the review pass that raised it.
+`;
+
+export default { name: NAME, install, uninstall };