hatch3r 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,3584 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/add.ts
+import chalk2 from "chalk";
+
+// src/cli/shared/ui.ts
+import chalk from "chalk";
+import ora from "ora";
+import boxen from "boxen";
+
+// src/version.ts
+var HATCH3R_VERSION = "1.0.0";
+
+// src/cli/shared/ui.ts
+var CYAN = chalk.hex("#06b6d4");
+var DIM_CYAN = chalk.hex("#67e8f9");
+var SHADOW_CHARS = new Set("\u2554\u2550\u2557\u255A\u255D\u2551");
+function gradient(text, from, to) {
+  const chars = [...text];
+  const len = chars.filter((c) => c !== " ").length;
+  let idx = 0;
+  return chars.map((c) => {
+    if (c === " ") return c;
+    const t = len > 1 ? idx / (len - 1) : 0;
+    idx++;
+    const r = Math.round(from[0] + (to[0] - from[0]) * t);
+    const g = Math.round(from[1] + (to[1] - from[1]) * t);
+    const b = Math.round(from[2] + (to[2] - from[2]) * t);
+    if (SHADOW_CHARS.has(c)) {
+      const DIM = 0.55;
+      return chalk.rgb(
+        Math.round(r * DIM),
+        Math.round(g * DIM),
+        Math.round(b * DIM)
+      )(c);
+    }
+    return chalk.rgb(r, g, b).bold(c);
+  }).join("");
+}
+var LOGO = [
+  "\u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551 \u255A\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551",
+  "\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D    \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D"
+].map((row) => gradient(row, [6, 182, 212], [20, 184, 166]));
+function buildBanner() {
+  const lines = [""];
+  for (const row of LOGO) {
+    lines.push(`  ${row}`);
+  }
+  lines.push(`  ${DIM_CYAN("Crack the egg. Hatch better agents.")}`);
+  lines.push(`  ${chalk.dim(`v${HATCH3R_VERSION}`)}`);
+  lines.push("");
+  return lines;
+}
+var BANNER_LINES = buildBanner();
+function printBanner(compact = false) {
+  if (compact) {
+    console.log(
+      `
+  ${CYAN.bold("hatch3r")} ${chalk.dim(`v${HATCH3R_VERSION}`)}
+`
+    );
+    return;
+  }
+  for (const line of BANNER_LINES) {
+    console.log(line);
+  }
+}
+function createSpinner(text) {
+  return ora({
+    text,
+    color: "cyan",
+    spinner: "dots",
+    indent: 2
+  });
+}
+function printBox(title, lines, style = "info") {
+  const colors = {
+    success: "#10b981",
+    info: "#06b6d4",
+    error: "#ef4444"
+  };
+  const content = lines.join("\n");
+  console.log(
+    boxen(content, {
+      title,
+      titleAlignment: "left",
+      padding: { top: 0, bottom: 0, left: 1, right: 1 },
+      margin: { top: 0, bottom: 1, left: 1, right: 0 },
+      borderColor: colors[style],
+      borderStyle: "round",
+      dimBorder: style === "info"
+    })
+  );
+}
+function error(msg) {
+  console.log(`  ${chalk.red("\u2716")} ${msg}`);
+}
+function warn(msg) {
+  console.log(`  ${chalk.yellow("\u26A0")} ${msg}`);
+}
+function info(msg) {
+  console.log(`  ${CYAN("\u2139")} ${msg}`);
+}
+function step(n, total, msg) {
+  return `${chalk.dim(`[${n}/${total}]`)} ${msg}`;
+}
+function label(name, value) {
+  return `${chalk.dim(name.padEnd(12))} ${value}`;
+}
+
+// src/cli/commands/add.ts
+async function addCommand() {
+  printBanner(true);
+  console.log();
+  console.log(chalk2.yellow("  Coming soon!"));
+  console.log(chalk2.dim("  The `add` command will allow installing community packs."));
+  console.log(chalk2.dim("  Follow https://github.com/hatch3r for updates."));
+  console.log();
+}
+
+// src/cli/commands/init.ts
+import { access as access3, cp, mkdir as mkdir2, readFile as readFile17, writeFile as writeFile4 } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname as dirname16, join as join18 } from "path";
+import { execFileSync } from "child_process";
+import chalk15 from "chalk";
+import inquirer from "inquirer";
+
+// src/adapters/aider.ts
+import { dirname } from "path";
+
+// src/types.ts
+var MANAGED_BLOCK_START = "<!-- HATCH3R:BEGIN -->";
+var MANAGED_BLOCK_END = "<!-- HATCH3R:END -->";
+var HATCH3R_PREFIX = "hatch3r-";
+var AGENTS_DIR = ".agents";
+function toPrefixedId(id, prefix = HATCH3R_PREFIX) {
+  const base = id.replace(new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "");
+  return `${prefix}${base}`;
+}
+var MANIFEST_FILE = "hatch.json";
+var DEFAULT_FEATURES = {
+  agents: true,
+  skills: true,
+  rules: true,
+  prompts: true,
+  commands: true,
+  mcp: true,
+  guardrails: false,
+  githubAgents: true,
+  hooks: true
+};
+var ENV_VAR_HELP = {
+  GITHUB_PAT: {
+    comment: "GitHub MCP server (classic PAT: repo, read:org \u2014 or fine-grained: Contents/Issues/PRs)",
+    url: "https://github.com/settings/tokens/new"
+  },
+  BRAVE_API_KEY: {
+    comment: "Brave Search (free: 2,000 queries/month)",
+    url: "https://brave.com/search/api/"
+  },
+  SENTRY_AUTH_TOKEN: {
+    comment: "Sentry error tracking",
+    url: "https://sentry.io/settings/account/api/auth-tokens/"
+  },
+  POSTGRES_URL: {
+    comment: "PostgreSQL connection string (e.g. postgresql://user:pass@host:5432/db)",
+    url: ""
+  },
+  LINEAR_API_KEY: {
+    comment: "Linear issue tracking",
+    url: "https://linear.app/settings/api"
+  }
+};
+var AVAILABLE_MCP_SERVERS = {
+  github: {
+    description: "GitHub repository management, code review, issues, PRs, and project boards",
+    requiresEnv: ["GITHUB_PAT"]
+  },
+  context7: {
+    description: "Up-to-date, version-specific library documentation for LLMs"
+  },
+  filesystem: {
+    description: "File management and code editing operations"
+  },
+  playwright: {
+    description: "Browser automation, web testing, and UI interaction"
+  },
+  "brave-search": {
+    description: "Web research, fact-checking, and current information retrieval",
+    requiresEnv: ["BRAVE_API_KEY"]
+  },
+  sentry: {
+    description: "Error tracking and performance monitoring (enable and configure with your Sentry auth token)",
+    requiresEnv: ["SENTRY_AUTH_TOKEN"]
+  },
+  postgres: {
+    description: "PostgreSQL database queries and schema inspection (enable and configure with your connection string)",
+    requiresEnv: ["POSTGRES_URL"]
+  },
+  linear: {
+    description: "Linear issue tracking and project management (enable and configure with your Linear API key)",
+    requiresEnv: ["LINEAR_API_KEY"]
+  }
+};
+
+// src/merge/managedBlocks.ts
+function insertManagedBlock(existingContent, managedContent) {
+  const startIdx = existingContent.indexOf(MANAGED_BLOCK_START);
+  const endIdx = existingContent.indexOf(MANAGED_BLOCK_END);
+  const block = `${MANAGED_BLOCK_START}
+${managedContent}
+${MANAGED_BLOCK_END}`;
+  if (startIdx === -1 || endIdx === -1) {
+    throw new Error("Content must contain managed block markers");
+  }
+  if (startIdx >= endIdx) {
+    throw new Error("Corrupted managed block: start marker must appear before end marker");
+  }
+  const before = existingContent.substring(0, startIdx);
+  const after = existingContent.substring(endIdx + MANAGED_BLOCK_END.length);
+  return `${before}${block}${after}`;
+}
+function extractManagedBlock(content) {
+  const startIdx = content.indexOf(MANAGED_BLOCK_START);
+  const endIdx = content.indexOf(MANAGED_BLOCK_END);
+  if (startIdx === -1 || endIdx === -1) {
+    return null;
+  }
+  return content.substring(startIdx + MANAGED_BLOCK_START.length, endIdx).trim();
+}
+function wrapInManagedBlock(content) {
+  return `${MANAGED_BLOCK_START}
+${content}
+${MANAGED_BLOCK_END}`;
+}
+function hasManagedBlock(content) {
+  return content.includes(MANAGED_BLOCK_START) && content.includes(MANAGED_BLOCK_END);
+}
+
+// src/cli/shared/agentsContent.ts
+var BRIDGE_ORCHESTRATION = `## Universal Sub-Agent Pipeline
+
+Every task \u2014 board-pickup, workflow command, plain chat, single-task, or multi-task \u2014 MUST use this three-phase sub-agent pipeline. There are NO exceptions. Never implement code inline; always delegate to sub-agents.
+
+**Phase 1 \u2014 Research:** Spawn \`hatch3r-researcher\` for context gathering. Skip only for trivial single-line edits (typos, comment fixes, single-value config changes).
+
+**Phase 2 \u2014 Implement:** Spawn \`hatch3r-implementer\` for ALL code changes. One dedicated implementer per task. Never implement inline \u2014 always delegate.
+
+**Phase 3 \u2014 Quality:** Spawn ALL applicable specialists in parallel after implementation:
+- \`hatch3r-reviewer\` \u2014 ALWAYS (mandatory for every task)
+- \`hatch3r-test-writer\` \u2014 ALWAYS for code changes (mandatory, not just bugs)
+- \`hatch3r-security-auditor\` \u2014 ALWAYS for code changes (mandatory, not just area:security)
+- \`hatch3r-docs-writer\` \u2014 ALWAYS evaluate; spawn when changes affect APIs, architecture, or user-facing behavior
+- \`hatch3r-lint-fixer\` \u2014 when lint errors present after implementation
+- \`hatch3r-a11y-auditor\` \u2014 when UI/accessibility changes
+- \`hatch3r-perf-profiler\` \u2014 when performance-sensitive changes
+- \`hatch3r-dependency-auditor\` \u2014 when dependencies change
+
+For plain chat tasks without issue context: classify the task (bug/feature/refactor/QA), create synthetic issue context (title, acceptance criteria, type), then run the full pipeline above.
+
+## Mandatory Behaviors
+
+1. **Load the matching skill** before implementing any task. Read \`/.agents/skills/\` for the skill matching the task type (bug-fix, feature, refactor, qa-validation, etc.).
+2. **Use the Task tool** (\`subagent_type: "generalPurpose"\`) for all agent delegations. Launch as many independent subagents in parallel as the platform supports \u2014 no artificial concurrency limit.
+3. **Propagate rules to subagents**: include all \`scope: always\` rule directives in subagent prompts \u2014 subagents do not inherit the parent's rule context automatically.
+4. **Consult learnings**: check \`/.agents/learnings/\` for relevant pitfalls and patterns before implementation.
+
+## Agent Quick Reference
+
+| Agent | When to Use |
+|-------|-------------|
+| \`hatch3r-researcher\` | ALWAYS before implementation (skip only for trivial single-line edits) |
+| \`hatch3r-implementer\` | ALWAYS. One dedicated implementer per task \u2014 standalone, epic sub-issue, batch, or plain chat |
+| \`hatch3r-reviewer\` | ALWAYS after implementation, before PR |
+| \`hatch3r-test-writer\` | ALWAYS for code changes |
+| \`hatch3r-security-auditor\` | ALWAYS for code changes |
+| \`hatch3r-docs-writer\` | ALWAYS evaluate; spawn when documentation impact exists |
+| \`hatch3r-lint-fixer\` | When lint/type errors present after implementation |
+| \`hatch3r-a11y-auditor\` | When UI/accessibility changes |
+| \`hatch3r-perf-profiler\` | When performance-sensitive changes |
+| \`hatch3r-dependency-auditor\` | When dependencies change |
+| \`hatch3r-ci-watcher\` | When CI fails |
+
+See the \`hatch3r-agent-orchestration\` rule in \`/.agents/rules/\` for the full orchestration protocol.
+
+## Canonical Structure
+
+- Rules: \`/.agents/rules/\` (source of truth for all tool-specific rules)
+- Agents: \`/.agents/agents/\` (agent definitions)
+- Skills: \`/.agents/skills/\` (skill workflows)
+- Commands: \`/.agents/commands/\` (executable commands)
+- MCP: \`/.agents/mcp/mcp.json\` (MCP server configuration)
+- Policy: \`/.agents/policy/\` (guardrails and deny lists)
+
+Do not manually edit files with the \`hatch3r-\` prefix -- they are managed by hatch3r
+and will be overwritten on update. Create non-prefixed files for customizations.`;
+var AGENTS_MD_INNER = [
+  "# Project Agent Instructions",
+  "",
+  "This project uses hatch3r for agentic coding setup.",
+  "Full canonical instructions are at `/.agents/AGENTS.md`.",
+  "",
+  "## Quick Reference",
+  "",
+  "- Rules: `/.agents/rules/`",
+  "- Agents: `/.agents/agents/`",
+  "- Skills: `/.agents/skills/`",
+  "- Commands: `/.agents/commands/`"
+].join("\n");
+var AGENTS_MD_FULL = `${wrapInManagedBlock(AGENTS_MD_INNER)}
+`;
+var CANONICAL_AGENTS_MD = `# hatch3r \u2014 Canonical Agent Instructions
+
+This file is the canonical reference for all agent orchestration in this project. It is auto-generated by hatch3r and should not be manually edited.
+
+## Universal Sub-Agent Pipeline
+
+Every task \u2014 board-pickup, workflow command, plain chat, single-task, or multi-task \u2014 MUST use this three-phase sub-agent pipeline. There are NO exceptions. Never implement code inline; always delegate to sub-agents.
+
+**Phase 1 \u2014 Research:** Spawn \`hatch3r-researcher\` for context gathering before implementation. Skip only for trivial single-line edits (typos, comment fixes, single-value config changes). Select research modes by task type.
+
+**Phase 2 \u2014 Implement:** Spawn \`hatch3r-implementer\` for ALL code changes. One dedicated implementer per task. Never implement inline \u2014 always delegate via the Task tool.
+
+**Phase 3 \u2014 Quality:** Spawn ALL applicable specialists in parallel after implementation completes:
+- \`hatch3r-reviewer\` \u2014 ALWAYS (mandatory for every task)
+- \`hatch3r-test-writer\` \u2014 ALWAYS for code changes (mandatory, not just bugs)
+- \`hatch3r-security-auditor\` \u2014 ALWAYS for code changes (mandatory, not just area:security)
+- \`hatch3r-docs-writer\` \u2014 ALWAYS evaluate; spawn when changes affect APIs, architecture, or user-facing behavior
+- \`hatch3r-lint-fixer\` \u2014 when lint errors present after implementation
+- \`hatch3r-a11y-auditor\` \u2014 when UI/accessibility changes
+- \`hatch3r-perf-profiler\` \u2014 when performance-sensitive changes
+- \`hatch3r-dependency-auditor\` \u2014 when dependencies change
+- \`hatch3r-ci-watcher\` \u2014 when CI fails
+
+This pipeline applies regardless of how the task was initiated. For plain chat tasks without issue context: classify the task (bug/feature/refactor/QA), create synthetic issue context (title, acceptance criteria, type), then run the full pipeline.
+
+## Orchestration Protocol
+
+Every task MUST follow this protocol:
+
+1. **Load the matching skill** from \`/.agents/skills/\` based on task type before implementation.
+2. **Spawn a researcher subagent** (\`hatch3r-researcher\`) for context gathering before implementation.
+3. **Spawn an implementer subagent** (\`hatch3r-implementer\`) for code changes. Never implement inline.
+4. **Spawn quality subagents** after implementation: reviewer, test-writer, and security-auditor (always for code changes), plus docs-writer, a11y-auditor, perf-profiler, lint-fixer as applicable.
+5. **Propagate rules** to all subagent prompts \u2014 subagents do not inherit rules automatically.
+6. **Consult learnings** from \`/.agents/learnings/\` before implementation.
+
+See the \`hatch3r-agent-orchestration\` rule in \`/.agents/rules/\` for the full mandatory protocol.
+
+## Agent Roster
+
+| Agent | Purpose | Invoke When |
+|-------|---------|-------------|
+| \`hatch3r-researcher\` | Context gathering across 12 research modes | ALWAYS before implementation (skip only for trivial single-line edits) |
+| \`hatch3r-implementer\` | Focused single-task implementation | ALWAYS. One dedicated implementer per task \u2014 standalone, epic sub-issue, batch, or plain chat. |
+| \`hatch3r-reviewer\` | Code review | ALWAYS after implementation, before PR creation |
+| \`hatch3r-test-writer\` | Regression and coverage tests | ALWAYS for code changes |
+| \`hatch3r-security-auditor\` | Security audit | ALWAYS for code changes |
+| \`hatch3r-docs-writer\` | Documentation maintenance | ALWAYS evaluate; spawn when documentation impact exists |
+| \`hatch3r-lint-fixer\` | Style, formatting, type cleanup | When lint errors present after implementation |
+| \`hatch3r-a11y-auditor\` | WCAG AA compliance | When UI/accessibility changes |
+| \`hatch3r-perf-profiler\` | Performance profiling | When performance-sensitive changes |
+| \`hatch3r-dependency-auditor\` | Supply chain security | When dependencies change |
+| \`hatch3r-ci-watcher\` | CI/CD failure diagnosis | When CI fails |
+
+## Skill Dispatch Table
+
+| Task Type | Skill |
+|-----------|-------|
+| \`type:bug\` | \`hatch3r-bug-fix\` |
+| \`type:feature\` | \`hatch3r-feature\` |
+| \`type:refactor\` + \`area:ui\` | \`hatch3r-visual-refactor\` |
+| \`type:refactor\` + behavior change | \`hatch3r-logical-refactor\` |
+| \`type:refactor\` (other) | \`hatch3r-refactor\` |
+| \`type:qa\` | \`hatch3r-qa-validation\` |
+
+## Researcher Mode Selection
+
+| Task Type | Recommended Modes |
+|-----------|-------------------|
+| \`type:bug\` | \`symptom-trace\`, \`root-cause\`, \`codebase-impact\` |
+| \`type:feature\` | \`codebase-impact\`, \`feature-design\`, \`architecture\` |
+| \`type:refactor\` | \`current-state\`, \`refactoring-strategy\`, \`migration-path\` |
+| \`type:qa\` | \`codebase-impact\` |
+
+## Subagent Spawning
+
+Use the Task tool with \`subagent_type: "generalPurpose"\` for all agent delegations. Launch as many independent subagents in parallel as the platform supports \u2014 no artificial concurrency limit. Every subagent prompt MUST include:
+
+- The agent protocol to follow
+- All \`scope: always\` rules from \`/.agents/rules/\`
+- The project's tooling hierarchy
+- Relevant learnings from \`/.agents/learnings/\`
+
+## Multi-Issue Parallelism
+
+When multiple issues or tasks are identified (board pickup batch, multiple issue references, or multi-task chat instructions), the framework MUST parallelize them:
+
+1. **Parse** into individual discrete tasks.
+2. **Build dependency graph**, group into parallel levels (independent = same level).
+3. **Phase 1 \u2014 Researchers:** Spawn one \`hatch3r-researcher\` per task in parallel. Skip for trivial single-line edits only.
+4. **Phase 2 \u2014 Implementers:** Spawn one \`hatch3r-implementer\` per task per dependency level. Each implementer receives its researcher output.
+5. **Phase 3 \u2014 Specialists:** Spawn \`hatch3r-reviewer\`, \`hatch3r-test-writer\`, and \`hatch3r-security-auditor\` (always for code changes), plus \`hatch3r-docs-writer\`, auditors, etc. as applicable across the batch.
+6. **Shared branch, combined PR** closing all issues.
+
+This pattern applies to ALL contexts: board-pickup, workflow command, and plain chat. Every task gets its own implementer subagent \u2014 never implement multiple tasks inline.
+
+## Single-Task and Plain Chat Protocol
+
+When the user provides a single task in plain chat (no command invoked, no issue reference), the full sub-agent pipeline still applies:
+
+1. **Classify** the task by type (bug/feature/refactor/QA/other) based on context.
+2. **Create synthetic issue context** (title, acceptance criteria, type) from the instruction.
+3. **Run the Universal Sub-Agent Pipeline**: Research \u2192 Implement \u2192 Quality (all three phases, all mandatory specialists).
+
+This ensures consistent quality regardless of how the task was initiated.
+
+## Directory Structure
+
+- \`/.agents/rules/\` \u2014 Rules (source of truth for all tool-specific rules)
+- \`/.agents/agents/\` \u2014 Agent definitions
+- \`/.agents/skills/\` \u2014 Skill workflows
+- \`/.agents/commands/\` \u2014 Executable commands
+- \`/.agents/mcp/\` \u2014 MCP server configuration
+- \`/.agents/policy/\` \u2014 Guardrails and deny lists
+- \`/.agents/learnings/\` \u2014 Project learnings (pitfalls, patterns, decisions)
+`;
+
+// src/adapters/base.ts
+function output(path, content, managedContent) {
+  return { path, content, managedContent, action: "create" };
+}
+
+// src/adapters/canonical.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+import chalk3 from "chalk";
+import { glob } from "glob";
+import { parse as parseYaml } from "yaml";
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/;
+function parseFrontmatter(rawContent) {
+  const match = rawContent.match(FRONTMATTER_REGEX);
+  if (!match) {
+    return {
+      metadata: { id: "", type: "rule", description: "" },
+      content: rawContent
+    };
+  }
+  const [, frontmatterStr, content = ""] = match;
+  const parsed = parseYaml(frontmatterStr ?? "");
+  const metadata = {
+    id: "",
+    type: "rule",
+    description: ""
+  };
+  if (parsed && typeof parsed === "object") {
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string") {
+        metadata[key] = value;
+      }
+    }
+  }
+  if (!metadata.id && metadata.name) {
+    metadata.id = metadata.name;
+  }
+  metadata.type = metadata.type ?? "rule";
+  metadata.description = metadata.description ?? "";
+  return { metadata, content: content ?? "" };
+}
+async function readCanonicalFiles(agentsDir, type) {
+  const results = [];
+  switch (type) {
+    case "rules": {
+      let files = [];
+      try {
+        files = await glob("**/*.md", {
+          cwd: join(agentsDir, "rules"),
+          nodir: true
+        });
+      } catch {
+        break;
+      }
+      const ruleEntries = await Promise.all(
+        files.map(async (relPath) => {
+          const fullPath = join(agentsDir, "rules", relPath);
+          const rawContent = await readFile(fullPath, "utf-8");
+          const { metadata, content } = parseFrontmatter(rawContent);
+          const id = metadata.id || relPath.replace(/\.md$/, "").replace(/\//g, "-");
+          return {
+            id,
+            type: "rule",
+            description: metadata.description ?? "",
+            scope: metadata.scope,
+            content,
+            rawContent,
+            sourcePath: fullPath
+          };
+        })
+      );
+      results.push(...ruleEntries);
+      break;
+    }
+    case "agents": {
+      let files = [];
+      try {
+        files = await glob("**/*.md", {
+          cwd: join(agentsDir, "agents"),
+          nodir: true
+        });
+      } catch {
+        break;
+      }
+      const agentEntries = await Promise.all(
+        files.map(async (relPath) => {
+          const fullPath = join(agentsDir, "agents", relPath);
+          const rawContent = await readFile(fullPath, "utf-8");
+          const { metadata, content } = parseFrontmatter(rawContent);
+          const id = metadata.id ?? metadata.name ?? relPath.replace(/\.md$/, "");
+          return {
+            id,
+            type: "agent",
+            description: metadata.description ?? "",
+            model: metadata.model,
+            content,
+            rawContent,
+            sourcePath: fullPath
+          };
+        })
+      );
+      results.push(...agentEntries);
+      break;
+    }
+    case "skills": {
+      let skillDirs = [];
+      try {
+        skillDirs = await readdir(join(agentsDir, "skills"), {
+          withFileTypes: true
+        });
+      } catch {
+        break;
+      }
+      const dirs = skillDirs.filter((d) => d.isDirectory());
+      const skillEntries = await Promise.all(
+        dirs.map(async (dir) => {
+          const skillPath = join(agentsDir, "skills", dir.name, "SKILL.md");
+          try {
+            const rawContent = await readFile(skillPath, "utf-8");
+            const { metadata, content } = parseFrontmatter(rawContent);
+            const id = metadata.name ?? metadata.id ?? dir.name;
+            return {
+              id,
+              type: "skill",
+              description: metadata.description ?? "",
+              content,
+              rawContent,
+              sourcePath: skillPath
+            };
+          } catch (err) {
+            const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+            if (code !== "ENOENT") {
+              console.warn(chalk3.yellow(`  Warning: Could not read SKILL.md in ${dir.name}: ${err instanceof Error ? err.message : String(err)}`));
+            }
+            return null;
+          }
+        })
+      );
+      results.push(...skillEntries.filter((e) => e !== null));
+      break;
+    }
+    case "commands": {
+      let files = [];
+      try {
+        files = await glob("**/*.md", {
+          cwd: join(agentsDir, "commands"),
+          nodir: true
+        });
+      } catch {
+        break;
+      }
+      const cmdEntries = await Promise.all(
+        files.map(async (relPath) => {
+          const fullPath = join(agentsDir, "commands", relPath);
+          const rawContent = await readFile(fullPath, "utf-8");
+          const { metadata, content } = parseFrontmatter(rawContent);
+          const id = metadata.id || relPath.replace(/\.md$/, "");
+          return {
+            id,
+            type: "command",
+            description: metadata.description ?? "",
+            content,
+            rawContent,
+            sourcePath: fullPath
+          };
+        })
+      );
+      results.push(...cmdEntries);
+      break;
+    }
+    case "prompts": {
+      const dir = join(agentsDir, "prompts");
+      try {
+        const files = await glob("**/*.md", { cwd: dir, nodir: true });
+        const promptEntries = await Promise.all(
+          files.map(async (relPath) => {
+            const fullPath = join(dir, relPath);
+            const rawContent = await readFile(fullPath, "utf-8");
+            const { metadata, content } = parseFrontmatter(rawContent);
+            const id = metadata.id ?? metadata.name ?? relPath.replace(/\.md$/, "");
+            return {
+              id,
+              type: "prompt",
+              description: metadata.description ?? "",
+              content,
+              rawContent,
+              sourcePath: fullPath
+            };
+          })
+        );
+        results.push(...promptEntries);
+      } catch (err) {
+        console.warn(chalk3.yellow(`  Warning: Could not read prompts: ${err instanceof Error ? err.message : String(err)}`));
+      }
+      break;
+    }
+    case "github-agents": {
+      const dir = join(agentsDir, "github-agents");
+      try {
+        const files = await glob("**/*.md", { cwd: dir, nodir: true });
+        const ghEntries = await Promise.all(
+          files.map(async (relPath) => {
+            const fullPath = join(dir, relPath);
+            const rawContent = await readFile(fullPath, "utf-8");
+            const { metadata, content } = parseFrontmatter(rawContent);
+            const id = metadata.id ?? metadata.name ?? relPath.replace(/\.md$/, "");
+            return {
+              id,
+              type: "github-agent",
+              description: metadata.description ?? "",
+              content,
+              rawContent,
+              sourcePath: fullPath
+            };
+          })
+        );
+        results.push(...ghEntries);
+      } catch (err) {
+        console.warn(chalk3.yellow(`  Warning: Could not read github-agents: ${err instanceof Error ? err.message : String(err)}`));
+      }
+      break;
+    }
+  }
+  return results;
+}
+
+// src/models/aliases.ts
+var MODEL_ALIASES = {
+  "opus": "claude-opus-4-6",
+  "sonnet": "claude-sonnet-4-6",
+  "haiku": "claude-haiku-4-5",
+  "codex": "gpt-5.3-codex",
+  "codex-prev": "gpt-5.2-codex",
+  "codex-mini": "gpt-5.1-codex-mini",
+  "codex-spark": "gpt-5.3-codex-spark",
+  "gemini-pro": "gemini-3.1-pro",
+  "gemini-flash": "gemini-3-flash",
+  "gemini-stable": "gemini-2.5-pro"
+};
+function resolveModelAlias(input) {
+  return MODEL_ALIASES[input] ?? input;
+}
+
+// src/models/resolve.ts
+function resolveAgentModel(agentId, agent, manifest, customize) {
+  const raw = customize?.model ?? manifest.models?.agents?.[agentId] ?? agent.model ?? manifest.models?.default;
+  return raw ? resolveModelAlias(raw) : void 0;
+}
+var PROVIDER_PREFIXES = [
+  [/^claude-/, "anthropic"],
+  [/^gpt-|^codex-/, "openai"],
+  [/^gemini-/, "google"]
+];
+function withProviderPrefix(modelId) {
+  for (const [pattern, provider] of PROVIDER_PREFIXES) {
+    if (pattern.test(modelId)) return `${provider}/${modelId}`;
+  }
+  return modelId;
+}
+
+// src/models/customize.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+async function readCustomization(projectRoot, type, id) {
+  const path = join2(projectRoot, ".hatch3r", type, `${id}.customize.yaml`);
+  try {
+    const raw = await readFile2(path, "utf-8");
+    const parsed = parseYaml2(raw);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const result = {};
+    let hasValue = false;
+    if (typeof parsed.model === "string" && parsed.model.length > 0) {
+      result.model = parsed.model;
+      hasValue = true;
+    }
+    if (typeof parsed.scope === "string" && parsed.scope.length > 0) {
+      result.scope = parsed.scope;
+      hasValue = true;
+    }
+    if (typeof parsed.description === "string" && parsed.description.length > 0) {
+      result.description = parsed.description;
+      hasValue = true;
+    }
+    if (typeof parsed.enabled === "boolean") {
+      result.enabled = parsed.enabled;
+      hasValue = true;
+    }
+    return hasValue ? result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readCustomizationMarkdown(projectRoot, type, id) {
+  const path = join2(projectRoot, ".hatch3r", type, `${id}.customize.md`);
+  try {
+    const content = await readFile2(path, "utf-8");
+    const trimmed = content.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/adapters/customization.ts
+var TYPE_TO_DIR = {
+  agent: "agents",
+  skill: "skills",
+  command: "commands",
+  rule: "rules"
+};
+async function applyCustomization(projectRoot, file) {
+  const dir = TYPE_TO_DIR[file.type];
+  if (!dir) {
+    return { content: file.content, skip: false, overrides: {} };
+  }
+  const [yaml, md] = await Promise.all([
+    readCustomization(projectRoot, dir, file.id),
+    readCustomizationMarkdown(projectRoot, dir, file.id)
+  ]);
+  const overrides = yaml ?? {};
+  if (overrides.enabled === false) {
+    return { content: file.content, skip: true, overrides };
+  }
+  let content = file.content;
+  if (md) {
+    content = `${content}
+
+---
+
+## Project Customizations
+
+${md}`;
+  }
+  return { content, skip: false, overrides };
+}
+async function applyCustomizationRaw(projectRoot, file) {
+  const dir = TYPE_TO_DIR[file.type];
+  if (!dir) {
+    return { content: file.rawContent, skip: false, overrides: {} };
+  }
+  const [yaml, md] = await Promise.all([
+    readCustomization(projectRoot, dir, file.id),
+    readCustomizationMarkdown(projectRoot, dir, file.id)
+  ]);
+  const overrides = yaml ?? {};
+  if (overrides.enabled === false) {
+    return { content: file.rawContent, skip: true, overrides };
+  }
+  let content = file.rawContent;
+  if (md) {
+    content = `${content}
+
+---
+
+## Project Customizations
+
+${md}`;
+  }
+  return { content, skip: false, overrides };
+}
+
+// src/adapters/aider.ts
+var AiderAdapter = class {
+  name = "aider";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname(agentsDir);
+    const conventionLines = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      ""
+    ];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        conventionLines.push(`## ${rule.id}`);
+        conventionLines.push("");
+        conventionLines.push(desc);
+        conventionLines.push("");
+        conventionLines.push(content);
+        conventionLines.push("");
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        conventionLines.push(`## Agent: ${agent.id}`);
+        if (model) conventionLines.push(`**Recommended model:** \`${model}\``);
+        conventionLines.push("");
+        conventionLines.push(desc);
+        conventionLines.push("");
+        conventionLines.push(content);
+        conventionLines.push("");
+      }
+    }
+    const conventionInner = conventionLines.join("\n");
+    results.push(output("CONVENTIONS.md", wrapInManagedBlock(conventionInner), conventionInner));
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.aider/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    const configYaml = [
+      "# Managed by hatch3r \u2014 do not edit manually",
+      "read:",
+      "  - CONVENTIONS.md",
+      "  - .agents/AGENTS.md",
+      "auto-lint: true",
+      ""
+    ].join("\n");
+    results.push(output(".aider.conf.yml", configYaml));
+    return results;
+  }
+};
+
+// src/adapters/amp.ts
+import { readFile as readFile3 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+import chalk4 from "chalk";
+var AmpAdapter = class {
+  name = "amp";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname2(agentsDir);
+    const bridgeLines = [];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        bridgeLines.push(`## ${rule.id}`);
+        bridgeLines.push("");
+        bridgeLines.push(desc);
+        bridgeLines.push("");
+        bridgeLines.push(content);
+        bridgeLines.push("");
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        bridgeLines.push(`## Agent: ${agent.id}`);
+        if (model) bridgeLines.push(`**Recommended model:** \`${model}\`. Use Smart mode for Opus, Rush for Haiku, Deep for Codex.`);
+        bridgeLines.push("");
+        bridgeLines.push(desc);
+        bridgeLines.push("");
+        bridgeLines.push(content);
+        bridgeLines.push("");
+      }
+    }
+    const innerContent = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      "",
+      ...bridgeLines
+    ].join("\n");
+    results.push(output(".amp/AGENTS.md", wrapInManagedBlock(innerContent), innerContent));
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.amp/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join3(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile3(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          const ampMcp = {};
+          for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+            if (server._disabled) continue;
+            if (server.command) {
+              ampMcp[name] = {
+                command: server.command,
+                args: server.args || [],
+                ...server.env && Object.keys(server.env).length > 0 ? { env: server.env } : {}
+              };
+            } else if (server.url) {
+              ampMcp[name] = { url: server.url };
+            }
+          }
+          if (Object.keys(ampMcp).length > 0) {
+            const ampSettings = {
+              "amp.mcpServers": ampMcp
+            };
+            results.push(
+              output(".amp/settings.json", JSON.stringify(ampSettings, null, 2))
+            );
+          }
+        }
+      } catch (err) {
+        console.warn(chalk4.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/claude.ts
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+import chalk5 from "chalk";
+function mapToClaudeEvent(event) {
+  const mapping = {
+    "pre-commit": "PreToolUse",
+    "post-merge": "PostToolUse",
+    "ci-failure": "SubagentStart",
+    "file-save": "PostToolUse",
+    "session-start": "SessionStart",
+    "pre-push": "PreToolUse"
+  };
+  return mapping[event] || event;
+}
+function getClaudeToolMatcher(hook) {
+  const eventToolMap = {
+    "pre-commit": "Bash",
+    "post-merge": "Bash",
+    "file-save": "Write",
+    "session-start": ".*",
+    "pre-push": "Bash",
+    "ci-failure": "Bash"
+  };
+  return eventToolMap[hook.event] || ".*";
+}
+var ClaudeAdapter = class {
+  name = "claude";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname3(agentsDir);
+    const innerContent = [
+      "",
+      "# Hatch3r Project Instructions",
+      "",
+      "Full canonical agent instructions are at `.agents/AGENTS.md`.",
+      "Rules are managed in `.claude/rules/` and agents in `.claude/agents/`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      "",
+      "## Agent Teams (Experimental)",
+      "",
+      "This project's sub-agentic architecture (implementer agent + issue workflow skill) is",
+      "compatible with Claude Code Agent Teams. When using Agent Teams:",
+      "",
+      "- Give each teammate explicit file boundaries in spawn prompts",
+      "- The hatch3r-implementer agent pattern maps to teammate spawn prompts",
+      "- Use `/.agents/skills/hatch3r-issue-workflow/SKILL.md` for orchestration",
+      "- Teammates do not inherit conversation history; include task-specific context",
+      "",
+      "## Personal Settings",
+      "",
+      "Create `CLAUDE.local.md` for personal settings (not committed to git).",
+      "Claude Code reads this file for user-specific preferences.",
+      ""
+    ].join("\n");
+    results.push(output("CLAUDE.md", wrapInManagedBlock(innerContent), innerContent));
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        const body = `# ${rule.id}
+
+${desc}
+
+${content}`;
+        results.push(output(`.claude/rules/${toPrefixedId(rule.id)}.md`, wrapInManagedBlock(body), body));
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const agentId = toPrefixedId(agent.id);
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const modelGuidance = model ? `
+
+## Recommended Model
+
+Preferred: \`${model}\`. Set via \`/model ${model}\` or env \`CLAUDE_CODE_SUBAGENT_MODEL=${model}\`.` : "";
+        const desc = overrides.description ?? agent.description;
+        const fm = `---
+description: ${desc}
+---`;
+        const body = `${content}${modelGuidance}`;
+        results.push(output(`.claude/agents/${agentId}.md`, `${fm}
+
+${wrapInManagedBlock(body)}`, body));
+      }
+    }
+    const settingsObj = {
+      permissions: {
+        allow: [
+          "Read",
+          "Edit",
+          "MultiEdit",
+          "Write",
+          "Grep",
+          "Glob",
+          "LS",
+          "TodoRead",
+          "TodoWrite"
+        ],
+        deny: []
+      },
+      teammateMode: "tool-using"
+    };
+    if (features.hooks) {
+      const { readHookDefinitions } = await import("./hooks-ZOTFDEA3.js");
+      const hooks = await readHookDefinitions(agentsDir);
+      if (hooks.length > 0) {
+        const hooksConfig = {};
+        for (const hook of hooks) {
+          const claudeEvent = mapToClaudeEvent(hook.event);
+          if (!hooksConfig[claudeEvent]) {
+            hooksConfig[claudeEvent] = [];
+          }
+          const matcher = getClaudeToolMatcher(hook);
+          hooksConfig[claudeEvent].push({
+            matcher,
+            hooks: [
+              {
+                type: "command",
+                command: `echo "hatch3r hook: ${hook.id} \u2014 activate ${hook.agent} agent"`
+              }
+            ]
+          });
+        }
+        settingsObj.hooks = hooksConfig;
+      }
+    }
+    results.push(
+      output(".claude/settings.json", JSON.stringify(settingsObj, null, 2))
+    );
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.claude/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, cmd);
+        if (skip) continue;
+        results.push(
+          output(
+            `.claude/commands/${toPrefixedId(cmd.id)}.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join4(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpContent = await readFile4(mcpPath, "utf-8");
+        results.push(output(".mcp.json", mcpContent));
+      } catch (err) {
+        console.warn(chalk5.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/cline.ts
+import { readFile as readFile5 } from "fs/promises";
+import { dirname as dirname4, join as join5 } from "path";
+import chalk6 from "chalk";
+var ClineAdapter = class {
+  name = "cline";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname4(agentsDir);
+    const customModes = [];
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const slug = toPrefixedId(agent.id);
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const modelGuidance = model ? `
+
+Recommended model: ${model}. Select this model in the Roo Code model dropdown when using this mode.` : "";
+        customModes.push({
+          slug,
+          name: agent.id,
+          roleDefinition: content + modelGuidance,
+          groups: ["read", "edit", "browser", "command", "mcp"],
+          whenToUse: overrides.description ?? agent.description
+        });
+      }
+    }
+    if (customModes.length > 0) {
+      results.push(
+        output(".roomodes", JSON.stringify({ customModes }, null, 2))
+      );
+    }
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.cline/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const ruleId = toPrefixedId(rule.id);
+        const desc = overrides.description ?? rule.description;
+        const body = `# ${rule.id}
+
+${desc}
+
+${content}`;
+        results.push(output(`.roo/rules/${ruleId}.md`, wrapInManagedBlock(body), body));
+      }
+    }
+    if (features.hooks) {
+      const { readHookDefinitions } = await import("./hooks-ZOTFDEA3.js");
+      const hooks = await readHookDefinitions(agentsDir);
+      for (const hook of hooks) {
+        const globs = hook.condition?.globs || [];
+        const body = [
+          `# Hook: ${hook.id}`,
+          "",
+          `**Event:** ${hook.event}`,
+          `**Agent:** ${hook.agent}`,
+          "",
+          hook.description,
+          "",
+          `When this hook's event (${hook.event}) is triggered${globs.length > 0 ? ` for files matching ${globs.join(", ")}` : ""}, activate the ${hook.agent} agent.`
+        ].join("\n");
+        const hookId = toPrefixedId(`hook-${hook.id}`);
+        results.push(output(`.roo/rules/${hookId}.md`, wrapInManagedBlock(body), body));
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, cmd);
+        if (skip) continue;
+        results.push(
+          output(
+            `.clinerules/workflows/${toPrefixedId(cmd.id)}.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join5(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile5(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          const rooMcp = {};
+          for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+            if (server._disabled) continue;
+            if (server.command) {
+              rooMcp[name] = {
+                command: server.command,
+                args: server.args || [],
+                ...server.env && Object.keys(server.env).length > 0 ? { env: server.env } : {}
+              };
+            } else if (server.url) {
+              rooMcp[name] = {
+                url: server.url,
+                transport: "streamable-http"
+              };
+            }
+          }
+          if (Object.keys(rooMcp).length > 0) {
+            results.push(
+              output(".roo/mcp.json", JSON.stringify({ mcpServers: rooMcp }, null, 2))
+            );
+          }
+        }
+      } catch (err) {
+        console.warn(chalk6.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/codex.ts
+import { readFile as readFile6 } from "fs/promises";
+import { dirname as dirname5, join as join6 } from "path";
+import chalk7 from "chalk";
+var CodexAdapter = class {
+  name = "codex";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const projectRoot = dirname5(agentsDir);
+    const configLines = [
+      "# Codex project configuration (managed by hatch3r)",
+      "#",
+      "# Do not manually edit \u2014 run `npx hatch3r sync` to regenerate.",
+      "",
+      'model_instructions_file = ".agents/AGENTS.md"',
+      ""
+    ];
+    if (manifest.features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      const enabledRules = [];
+      for (const rule of rules) {
+        const { skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        enabledRules.push({ ...rule, description: desc });
+      }
+      if (enabledRules.length > 0) {
+        configLines.push("# Additional instruction files (rules)");
+        for (const rule of enabledRules) {
+          configLines.push(`# rule: ${rule.id} \u2014 ${rule.description}`);
+        }
+        configLines.push("");
+      }
+    }
+    if (manifest.features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const agentId = toPrefixedId(agent.id);
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        configLines.push(`[agents.${agentId}]`);
+        configLines.push(`model_instructions_file = ".agents/agents/${agent.id}.md"`);
+        if (model) configLines.push(`model = "${model}"`);
+        configLines.push("");
+      }
+    }
+    if (manifest.features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join6(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile6(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+            if (server._disabled) continue;
+            configLines.push(`[mcp_servers.${name}]`);
+            if (server.command) {
+              configLines.push(`command = "${server.command}"`);
+              if (server.args && server.args.length > 0) {
+                const argsStr = server.args.map((a) => `"${a}"`).join(", ");
+                configLines.push(`args = [${argsStr}]`);
+              }
+            } else if (server.url) {
+              configLines.push(`url = "${server.url}"`);
+            }
+            if (server.env) {
+              for (const [k, v] of Object.entries(server.env)) {
+                configLines.push(`env.${k} = "${v}"`);
+              }
+            }
+            configLines.push("");
+          }
+        }
+      } catch (err) {
+        console.warn(chalk7.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    results.push(output(".codex/config.toml", configLines.join("\n")));
+    if (manifest.features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.codex/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/copilot.ts
+import { existsSync } from "fs";
+import { readFile as readFile7 } from "fs/promises";
+import { dirname as dirname6, join as join7 } from "path";
+import chalk8 from "chalk";
+function detectInstallCommand(projectRoot) {
+  if (existsSync(join7(projectRoot, "bun.lockb"))) return { install: "bun install", build: "bun run build" };
+  if (existsSync(join7(projectRoot, "pnpm-lock.yaml"))) return { install: "pnpm install --frozen-lockfile", build: "pnpm run build" };
+  if (existsSync(join7(projectRoot, "yarn.lock"))) return { install: "yarn install --frozen-lockfile", build: "yarn build" };
+  return { install: "npm ci", build: "npm run build" };
+}
+var CopilotAdapter = class {
+  name = "copilot";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname6(agentsDir);
+    const alwaysRules = [];
+    const scopedRules = [];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const scope = overrides.scope ?? rule.scope;
+        if (scope && scope !== "always") {
+          scopedRules.push({ rule: { ...rule, description: overrides.description ?? rule.description }, content, scope });
+        } else {
+          alwaysRules.push({ rule: { ...rule, description: overrides.description ?? rule.description }, content });
+        }
+      }
+    }
+    const innerContent = [
+      "",
+      "# Hatch3r Project Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      "",
+      "## Hatch3r Rules",
+      "",
+      ...alwaysRules.map(
+        (r) => `### ${r.rule.id}
+
+${r.rule.description}
+
+${r.content}`
+      ),
+      ""
+    ].join("\n");
+    results.push(
+      output(".github/copilot-instructions.md", wrapInManagedBlock(innerContent), innerContent)
+    );
+    const { install, build } = detectInstallCommand(projectRoot);
+    const copilotSetupSteps = `name: "Copilot Setup Steps"
+on: [push]
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install dependencies
+        run: ${install}
+      - name: Build
+        run: ${build}
+`;
+    results.push(output(".github/workflows/copilot-setup-steps.yml", copilotSetupSteps));
+    for (const { rule, content, scope } of scopedRules) {
+      const globs = scope.includes(",") ? scope.split(",").map((g) => g.trim()) : [scope];
+      const applyTo = globs.join(", ");
+      const fm = `---
+applyTo: "${applyTo}"
+---`;
+      const body = `# ${rule.id}
+
+${rule.description}
+
+${content}`;
+      results.push(
+        output(
+          `.github/instructions/${toPrefixedId(rule.id)}.instructions.md`,
+          `${fm}
+
+${wrapInManagedBlock(body)}`,
+          body
+        )
+      );
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        const lines = [
+          `name: ${agent.id}`,
+          `description: ${desc}`
+        ];
+        if (model) lines.push(`model: ${model}`);
+        const fm = `---
+${lines.join("\n")}
+---`;
+        results.push(
+          output(
+            `.github/agents/${toPrefixedId(agent.id)}.md`,
+            `${fm}
+
+${wrapInManagedBlock(content)}`,
+            content
+          )
+        );
+      }
+    }
+    if (features.prompts) {
+      const prompts = await readCanonicalFiles(agentsDir, "prompts");
+      for (const prompt of prompts) {
+        const body = prompt.rawContent;
+        results.push(
+          output(
+            `.github/prompts/${toPrefixedId(prompt.id)}.prompt.md`,
+            wrapInManagedBlock(body),
+            body
+          )
+        );
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, cmd);
+        if (skip) continue;
+        results.push(
+          output(
+            `.github/copilot/commands/${toPrefixedId(cmd.id)}.prompt.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.githubAgents) {
+      const ghAgents = await readCanonicalFiles(agentsDir, "github-agents");
+      for (const agent of ghAgents) {
+        const body = agent.rawContent;
+        results.push(
+          output(
+            `.github/copilot/agents/${toPrefixedId(agent.id)}.md`,
+            wrapInManagedBlock(body),
+            body
+          )
+        );
+      }
+    }
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, skill);
+        if (skip) continue;
+        const desc = overrides.description ?? skill.description;
+        const fm = `---
+name: ${skill.id}
+description: ${desc}
+---`;
+        results.push(
+          output(
+            `.github/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            `${fm}
+
+${wrapInManagedBlock(content)}`,
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join7(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile7(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          for (const server of Object.values(mcpParsed.mcpServers)) {
+            if (server.command) {
+              server.envFile = "${workspaceFolder}/.env.mcp";
+            }
+          }
+        }
+        results.push(
+          output(
+            ".vscode/mcp.json",
+            JSON.stringify(mcpParsed, null, 2) + "\n"
+          )
+        );
+      } catch (err) {
+        console.warn(chalk8.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/cursor.ts
+import { readFile as readFile8 } from "fs/promises";
+import { dirname as dirname7, join as join8 } from "path";
+import chalk9 from "chalk";
+function cursorRuleFrontmatter(rule, scopeOverride) {
+  const scope = scopeOverride ?? rule.scope;
+  const lines = [`description: ${rule.description}`];
+  if (scope === "always") {
+    lines.push("alwaysApply: true");
+  } else if (scope) {
+    const globs = scope.includes(",") ? scope.split(",").map((g) => g.trim()) : [scope];
+    lines.push(`globs: [${globs.map((g) => `"${g}"`).join(", ")}]`);
+  } else {
+    lines.push("alwaysApply: false");
+  }
+  return `---
+${lines.join("\n")}
+---`;
+}
+function mdcOutput(path, frontmatter, body) {
+  return output(path, `${frontmatter}
+
+${wrapInManagedBlock(body)}`, body);
+}
+var CursorAdapter = class {
+  name = "cursor";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname7(agentsDir);
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        const ruleWithDesc = { ...rule, description: desc };
+        const baseName = `${toPrefixedId(rule.id)}.mdc`;
+        results.push(
+          mdcOutput(`.cursor/rules/${baseName}`, cursorRuleFrontmatter(ruleWithDesc, overrides.scope), content)
+        );
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        const lines = [
+          `name: ${agent.id}`,
+          `description: ${desc}`
+        ];
+        if (model) lines.push(`model: ${model}`);
+        const fm = `---
+${lines.join("\n")}
+---`;
+        results.push(
+          mdcOutput(`.cursor/agents/${toPrefixedId(agent.id)}.md`, fm, content)
+        );
+      }
+    }
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, skill);
+        if (skip) continue;
+        const desc = overrides.description ?? skill.description;
+        const fm = `---
+name: ${skill.id}
+description: ${desc}
+---`;
+        results.push(
+          mdcOutput(`.cursor/skills/${toPrefixedId(skill.id)}/SKILL.md`, fm, content)
+        );
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, cmd);
+        if (skip) continue;
+        results.push(
+          output(
+            `.cursor/commands/${toPrefixedId(cmd.id)}.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join8(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpContent = await readFile8(mcpPath, "utf-8");
+        results.push(output(".cursor/mcp.json", mcpContent));
+      } catch (err) {
+        console.warn(chalk9.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    if (features.hooks) {
+      const { readHookDefinitions } = await import("./hooks-ZOTFDEA3.js");
+      const hooks = await readHookDefinitions(agentsDir);
+      for (const hook of hooks) {
+        const globs = hook.condition?.globs || [];
+        const globLine = globs.length > 0 ? `globs: [${globs.map((g) => `"${g}"`).join(", ")}]` : "alwaysApply: false";
+        const fm = `---
+description: "Hook: ${hook.description}"
+${globLine}
+---`;
+        const body = `# Hook: ${hook.id}
+
+**Event:** ${hook.event}
+**Agent:** ${hook.agent}
+
+${hook.description}
+
+When this hook's event (${hook.event}) is triggered${globs.length > 0 ? ` for files matching ${globs.join(", ")}` : ""}, activate the ${hook.agent} agent.`;
+        results.push(
+          mdcOutput(`.cursor/rules/${toPrefixedId(`hook-${hook.id}`)}.mdc`, fm, body)
+        );
+      }
+    }
+    const bridgeFm = `---
+description: Bridge to canonical agent instructions and mandatory orchestration directives
+alwaysApply: true
+---`;
+    const bridgeBody = `# Hatch3r Bridge
+
+This project uses hatch3r for agentic coding setup.
+Canonical agent instructions live at \`/.agents/AGENTS.md\`.
+
+${BRIDGE_ORCHESTRATION}`;
+    results.push(mdcOutput(".cursor/rules/hatch3r-bridge.mdc", bridgeFm, bridgeBody));
+    if (manifest.tools.includes("cursor")) {
+      const envConfig = {
+        instructions: ["Read /.agents/AGENTS.md for project instructions"],
+        mcpServers: {}
+      };
+      results.push(output(".cursor/environment.json", JSON.stringify(envConfig, null, 2) + "\n"));
+    }
+    return results;
+  }
+};
+
+// src/adapters/gemini.ts
+import { readFile as readFile9 } from "fs/promises";
+import { dirname as dirname8, join as join9 } from "path";
+import chalk10 from "chalk";
+function escapeTomlString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function mapToGeminiEvent(event) {
+  const mapping = {
+    "pre-commit": "BeforeTool",
+    "post-merge": "AfterTool",
+    "ci-failure": "AfterAgent",
+    "file-save": "AfterTool",
+    "session-start": "SessionStart",
+    "pre-push": "BeforeTool"
+  };
+  return mapping[event] || event;
+}
+var GeminiAdapter = class {
+  name = "gemini";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname8(agentsDir);
+    const geminiMdLines = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      ""
+    ];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        geminiMdLines.push(`## ${rule.id}`);
+        geminiMdLines.push("");
+        geminiMdLines.push(desc);
+        geminiMdLines.push("");
+        geminiMdLines.push(content);
+        geminiMdLines.push("");
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        geminiMdLines.push(`## Agent: ${agent.id}`);
+        geminiMdLines.push("");
+        geminiMdLines.push(desc);
+        geminiMdLines.push("");
+        geminiMdLines.push(content);
+        if (model) {
+          geminiMdLines.push("");
+          geminiMdLines.push(`**Recommended model:** \`${model}\`. Set via \`gemini --model ${model}\` or select in Google AI Studio.`);
+        }
+        geminiMdLines.push("");
+      }
+    }
+    const geminiInner = geminiMdLines.join("\n");
+    results.push(output("GEMINI.md", wrapInManagedBlock(geminiInner), geminiInner));
+    const settings = {
+      context: {
+        fileName: ["GEMINI.md", "AGENTS.md"]
+      }
+    };
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join9(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile9(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          const geminiMcp = {};
+          for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+            if (server._disabled) continue;
+            if (server.command) {
+              geminiMcp[name] = {
+                command: server.command,
+                args: server.args || [],
+                ...server.env && Object.keys(server.env).length > 0 ? { env: server.env } : {}
+              };
+            } else if (server.url) {
+              geminiMcp[name] = { url: server.url };
+            }
+          }
+          if (Object.keys(geminiMcp).length > 0) {
+            settings.mcpServers = geminiMcp;
+          }
+        }
+      } catch (err) {
+        console.warn(chalk10.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    if (features.hooks) {
+      const { readHookDefinitions } = await import("./hooks-ZOTFDEA3.js");
+      const hooks = await readHookDefinitions(agentsDir);
+      if (hooks.length > 0) {
+        const hooksObj = {};
+        for (const hook of hooks) {
+          const geminiEvent = mapToGeminiEvent(hook.event);
+          if (!hooksObj[geminiEvent]) {
+            hooksObj[geminiEvent] = [];
+          }
+          const matcher = hook.condition?.globs?.join("|") || ".*";
+          hooksObj[geminiEvent].push({
+            matcher,
+            hooks: [
+              {
+                type: "command",
+                command: `echo "hatch3r hook: ${hook.id} \u2014 activate ${hook.agent} agent"`
+              }
+            ]
+          });
+        }
+        settings.hooks = hooksObj;
+      }
+    }
+    results.push(output(".gemini/settings.json", JSON.stringify(settings, null, 2)));
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.gemini/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, cmd);
+        if (skip) continue;
+        const desc = overrides.description ?? cmd.description;
+        const toml = [
+          `description = "${escapeTomlString(desc)}"`,
+          `prompt = "${escapeTomlString(content)}"`
+        ].join("\n");
+        results.push(
+          output(`.gemini/commands/${toPrefixedId(cmd.id)}.toml`, toml)
+        );
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/goose.ts
+import { dirname as dirname9 } from "path";
+var GooseAdapter = class {
+  name = "goose";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname9(agentsDir);
+    const hintLines = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      ""
+    ];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        hintLines.push(`## ${rule.id}`);
+        hintLines.push("");
+        hintLines.push(desc);
+        hintLines.push("");
+        hintLines.push(content);
+        hintLines.push("");
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        hintLines.push(`## Agent: ${agent.id}`);
+        if (model) hintLines.push(`**Recommended model:** \`${model}\``);
+        hintLines.push("");
+        hintLines.push(desc);
+        hintLines.push("");
+        hintLines.push(content);
+        hintLines.push("");
+      }
+    }
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        hintLines.push(`## Skill: ${toPrefixedId(skill.id)}`);
+        hintLines.push("");
+        hintLines.push(content);
+        hintLines.push("");
+      }
+    }
+    const hintInner = hintLines.join("\n");
+    results.push(output(".goosehints", wrapInManagedBlock(hintInner), hintInner));
+    return results;
+  }
+};
+
+// src/adapters/kiro.ts
+import { readFile as readFile10 } from "fs/promises";
+import { dirname as dirname10, join as join10 } from "path";
+import chalk11 from "chalk";
+function steeringFrontmatter(globs) {
+  if (!globs) return "";
+  return `---
+inclusion: conditional
+globs: "${globs}"
+---
+
+`;
+}
+var KiroAdapter = class {
+  name = "kiro";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname10(agentsDir);
+    const steeringLines = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      ""
+    ];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const scope = overrides.scope ?? rule.scope;
+        const desc = overrides.description ?? rule.description;
+        if (scope && scope !== "always") {
+          const globs = scope.includes("*") ? scope : `${scope}/**`;
+          const fm = steeringFrontmatter(globs);
+          const body = `# ${rule.id}
+
+${desc}
+
+${content}`;
+          results.push(
+            output(
+              `.kiro/steering/${toPrefixedId(rule.id)}.md`,
+              `${fm}${wrapInManagedBlock(body)}`,
+              body
+            )
+          );
+        } else {
+          steeringLines.push(`## ${rule.id}`);
+          steeringLines.push("");
+          steeringLines.push(desc);
+          steeringLines.push("");
+          steeringLines.push(content);
+          steeringLines.push("");
+        }
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        steeringLines.push(`## Agent: ${agent.id}`);
+        if (model) steeringLines.push(`**Recommended model:** \`${model}\``);
+        steeringLines.push("");
+        steeringLines.push(desc);
+        steeringLines.push("");
+        steeringLines.push(content);
+        steeringLines.push("");
+      }
+    }
+    const steeringInner = steeringLines.join("\n");
+    results.push(
+      output(
+        ".kiro/steering/hatch3r-agents.md",
+        wrapInManagedBlock(steeringInner),
+        steeringInner
+      )
+    );
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.kiro/steering/${toPrefixedId(skill.id)}.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join10(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile10(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          const kiroMcp = {};
+          for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+            if (server._disabled) continue;
+            if (server.command) {
+              kiroMcp[name] = {
+                command: server.command,
+                args: server.args || [],
+                ...server.env && Object.keys(server.env).length > 0 ? { env: server.env } : {}
+              };
+            } else if (server.url) {
+              kiroMcp[name] = { url: server.url };
+            }
+          }
+          if (Object.keys(kiroMcp).length > 0) {
+            results.push(
+              output(
+                ".kiro/settings/mcp.json",
+                JSON.stringify({ mcpServers: kiroMcp }, null, 2)
+              )
+            );
+          }
+        }
+      } catch (err) {
+        console.warn(chalk11.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/opencode.ts
+import { readFile as readFile11 } from "fs/promises";
+import { dirname as dirname11, join as join11 } from "path";
+import chalk12 from "chalk";
+var OpenCodeAdapter = class {
+  name = "opencode";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname11(agentsDir);
+    const instructions = [".agents/AGENTS.md"];
+    if (features.rules) instructions.push(".agents/rules/*.md");
+    if (features.agents) instructions.push(".agents/agents/*.md");
+    if (features.skills) instructions.push(".agents/skills/*/SKILL.md");
+    if (features.commands) instructions.push(".agents/commands/*.md");
+    const opencodeConfig = {
+      $schema: "https://opencode.ai/config-schema.json",
+      instructions
+    };
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join11(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile11(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          const mcp = {};
+          for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+            if (server._disabled) continue;
+            if (server.command) {
+              const cmd = [server.command, ...server.args || []];
+              mcp[name] = {
+                type: "local",
+                command: cmd,
+                enabled: true,
+                ...server.env && Object.keys(server.env).length > 0 ? { environment: server.env } : {}
+              };
+            } else if (server.url) {
+              mcp[name] = {
+                type: "remote",
+                url: server.url,
+                enabled: true
+              };
+            }
+          }
+          if (Object.keys(mcp).length > 0) {
+            opencodeConfig.mcp = mcp;
+          }
+        }
+      } catch (err) {
+        console.warn(chalk12.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    results.push(output("opencode.json", JSON.stringify(opencodeConfig, null, 2)));
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const agentId = toPrefixedId(agent.id);
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        const lines = [`description: ${desc}`];
+        if (model) lines.push(`model: ${withProviderPrefix(model)}`);
+        const fm = `---
+${lines.join("\n")}
+---`;
+        results.push(
+          output(
+            `.opencode/agents/${agentId}.md`,
+            `${fm}
+
+${wrapInManagedBlock(content)}`,
+            content
+          )
+        );
+      }
+    }
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, skill);
+        if (skip) continue;
+        results.push(
+          output(
+            `.opencode/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, cmd);
+        if (skip) continue;
+        results.push(
+          output(
+            `.opencode/commands/${toPrefixedId(cmd.id)}.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/windsurf.ts
+import { readFile as readFile12 } from "fs/promises";
+import { dirname as dirname12, join as join12 } from "path";
+import chalk13 from "chalk";
+function isGlobPattern(scope) {
+  return scope.includes("*") || scope.includes("?") || scope.includes("[");
+}
+function ruleTrigger(scope) {
+  if (!scope) return "model_decision";
+  if (scope === "always") return "always_on";
+  return "glob_pattern";
+}
+var WindsurfAdapter = class {
+  name = "windsurf";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname12(agentsDir);
+    const windsurfrulesLines = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "Rules and skills are managed in `.windsurf/rules/` and `.windsurf/skills/`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      ""
+    ];
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        windsurfrulesLines.push(`## Agent: ${agent.id}`);
+        if (model) windsurfrulesLines.push(`**Recommended model:** \`${model}\``);
+        windsurfrulesLines.push("");
+        windsurfrulesLines.push(overrides.description ?? agent.description);
+        windsurfrulesLines.push("");
+        windsurfrulesLines.push(content);
+        windsurfrulesLines.push("");
+      }
+    }
+    const windsurfInner = windsurfrulesLines.join("\n");
+    results.push(output(".windsurfrules", wrapInManagedBlock(windsurfInner), windsurfInner));
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const scope = overrides.scope ?? rule.scope;
+        const trigger = ruleTrigger(scope);
+        const globScope = trigger === "glob_pattern" && scope ? isGlobPattern(scope) ? scope : `${scope}/**` : void 0;
+        const fm = `<!-- trigger: ${trigger}${globScope ? `, globs: ${globScope}` : ""} -->`;
+        const desc = overrides.description ?? rule.description;
+        const body = `# ${rule.id}
+
+${desc}
+
+${content}`;
+        results.push(
+          output(
+            `.windsurf/rules/${toPrefixedId(rule.id)}.md`,
+            `${fm}
+
+${wrapInManagedBlock(body)}`,
+            body
+          )
+        );
+      }
+    }
+    if (features.skills) {
+      const skills = await readCanonicalFiles(agentsDir, "skills");
+      for (const skill of skills) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, skill);
+        if (skip) continue;
+        const desc = overrides.description ?? skill.description;
+        const fm = `---
+name: ${skill.id}
+description: ${desc}
+---`;
+        results.push(
+          output(
+            `.windsurf/skills/${toPrefixedId(skill.id)}/SKILL.md`,
+            `${fm}
+
+${wrapInManagedBlock(content)}`,
+            content
+          )
+        );
+      }
+    }
+    if (features.commands) {
+      const commands = await readCanonicalFiles(agentsDir, "commands");
+      for (const cmd of commands) {
+        const { content, skip } = await applyCustomizationRaw(projectRoot, cmd);
+        if (skip) continue;
+        results.push(
+          output(
+            `.windsurf/workflows/${toPrefixedId(cmd.id)}.md`,
+            wrapInManagedBlock(content),
+            content
+          )
+        );
+      }
+    }
+    if (features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join12(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpRaw = await readFile12(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpRaw);
+        if (mcpParsed.mcpServers) {
+          results.push(
+            output(".windsurf/mcp.json", JSON.stringify(mcpParsed, null, 2) + "\n")
+          );
+        }
+      } catch (err) {
+        console.warn(chalk13.yellow(`  Warning: Could not read MCP config: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+    return results;
+  }
+};
+
+// src/adapters/zed.ts
+import { dirname as dirname13 } from "path";
+var ZedAdapter = class {
+  name = "zed";
+  async generate(agentsDir, manifest) {
+    const results = [];
+    const { features } = manifest;
+    const projectRoot = dirname13(agentsDir);
+    const rulesLines = [
+      "",
+      "# Hatch3r Agent Instructions",
+      "",
+      "Full canonical agent instructions are at `/.agents/AGENTS.md`.",
+      "",
+      BRIDGE_ORCHESTRATION,
+      ""
+    ];
+    if (features.rules) {
+      const rules = await readCanonicalFiles(agentsDir, "rules");
+      for (const rule of rules) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, rule);
+        if (skip) continue;
+        const desc = overrides.description ?? rule.description;
+        rulesLines.push(`## ${rule.id}`);
+        rulesLines.push("");
+        rulesLines.push(desc);
+        rulesLines.push("");
+        rulesLines.push(content);
+        rulesLines.push("");
+      }
+    }
+    if (features.agents) {
+      const agents = await readCanonicalFiles(agentsDir, "agents");
+      for (const agent of agents) {
+        const { content, skip, overrides } = await applyCustomization(projectRoot, agent);
+        if (skip) continue;
+        const model = resolveAgentModel(agent.id, agent, manifest, overrides);
+        const desc = overrides.description ?? agent.description;
+        rulesLines.push(`## Agent: ${agent.id}`);
+        if (model) rulesLines.push(`**Recommended model:** \`${model}\``);
+        rulesLines.push("");
+        rulesLines.push(desc);
+        rulesLines.push("");
+        rulesLines.push(content);
+        rulesLines.push("");
+      }
+    }
+    const rulesInner = rulesLines.join("\n");
+    results.push(output(".rules", wrapInManagedBlock(rulesInner), rulesInner));
+    return results;
+  }
+};
+
+// src/adapters/index.ts
+var adapters = {
+  cursor: new CursorAdapter(),
+  copilot: new CopilotAdapter(),
+  claude: new ClaudeAdapter(),
+  opencode: new OpenCodeAdapter(),
+  windsurf: new WindsurfAdapter(),
+  amp: new AmpAdapter(),
+  codex: new CodexAdapter(),
+  gemini: new GeminiAdapter(),
+  cline: new ClineAdapter(),
+  aider: new AiderAdapter(),
+  kiro: new KiroAdapter(),
+  goose: new GooseAdapter(),
+  zed: new ZedAdapter()
+};
+function getAdapter(tool) {
+  const adapter = adapters[tool];
+  if (!adapter) {
+    throw new Error(`Unknown tool: ${tool}`);
+  }
+  return adapter;
+}
+
+// src/manifest/hatchJson.ts
+import { readFile as readFile13, writeFile } from "fs/promises";
+import { join as join13 } from "path";
+import chalk14 from "chalk";
+function createMinimalBoardConfig(owner, repo, defaultBranch) {
+  return {
+    owner,
+    repo,
+    defaultBranch,
+    projectNumber: null,
+    statusFieldId: null,
+    statusOptions: {
+      backlog: null,
+      ready: null,
+      inProgress: null,
+      inReview: null,
+      done: null
+    },
+    labels: {
+      types: ["type:bug", "type:feature", "type:refactor", "type:qa", "type:docs", "type:infra"],
+      executors: ["executor:agent", "executor:human", "executor:hybrid"],
+      statuses: ["status:triage", "status:ready", "status:in-progress", "status:in-review", "status:blocked"],
+      meta: ["meta:board-overview"]
+    },
+    branchConvention: "{type}/{short-description}",
+    areas: []
+  };
+}
+function createManifest(options) {
+  const owner = options.owner ?? "";
+  const repo = options.repo ?? "";
+  const manifest = {
+    version: "1.0.0",
+    hatch3rVersion: HATCH3R_VERSION,
+    owner,
+    repo,
+    tools: options.tools,
+    features: { ...DEFAULT_FEATURES, ...options.features },
+    mcp: { servers: options.mcpServers ?? [] },
+    managedFiles: []
+  };
+  if (options.defaultBranch) {
+    manifest.board = createMinimalBoardConfig(owner, repo, options.defaultBranch);
+  }
+  return manifest;
+}
+function validateManifest(data) {
+  if (!data || typeof data !== "object") return false;
+  const obj = data;
+  return typeof obj.version === "string" && typeof obj.hatch3rVersion === "string" && Array.isArray(obj.tools) && obj.features !== null && typeof obj.features === "object" && obj.mcp !== null && typeof obj.mcp === "object" && Array.isArray(obj.managedFiles);
+}
+async function readManifest(rootDir) {
+  const manifestPath = join13(rootDir, AGENTS_DIR, MANIFEST_FILE);
+  let raw;
+  try {
+    raw = await readFile13(manifestPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `Malformed JSON in ${manifestPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (!validateManifest(parsed)) {
+    console.error(chalk14.red("Invalid .agents/hatch.json: missing required fields (version, hatch3rVersion, tools, features, managedFiles)"));
+    return null;
+  }
+  return parsed;
+}
+async function writeManifest(rootDir, manifest) {
+  const manifestPath = join13(rootDir, AGENTS_DIR, MANIFEST_FILE);
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+function addManagedFile(manifest, filePath) {
+  if (!manifest.managedFiles.includes(filePath)) {
+    manifest.managedFiles.push(filePath);
+  }
+}
+
+// src/merge/safeWrite.ts
+import {
+  readFile as readFile14,
+  writeFile as writeFile2,
+  mkdir,
+  access,
+  copyFile
+} from "fs/promises";
+import { join as join14, dirname as dirname14, basename } from "path";
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBackup(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = join14(dirname14(filePath), ".backups");
+  await mkdir(backupDir, { recursive: true });
+  const backupPath = join14(backupDir, `${timestamp}_${basename(filePath)}`);
+  await copyFile(filePath, backupPath);
+  return backupPath;
+}
+async function writeWithBackup(filePath, content, shouldBackup) {
+  if (shouldBackup) {
+    const backup = await createBackup(filePath);
+    await writeFile2(filePath, content, "utf-8");
+    return { path: filePath, action: "backed-up", backup };
+  }
+  await writeFile2(filePath, content, "utf-8");
+  return { path: filePath, action: "updated" };
+}
+async function safeWriteFile(filePath, content, options = {}) {
+  await mkdir(dirname14(filePath), { recursive: true });
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    await writeFile2(filePath, content, "utf-8");
+    return { path: filePath, action: "created" };
+  }
+  const existingContent = await readFile14(filePath, "utf-8");
+  if (options.managedContent) {
+    if (!hasManagedBlock(existingContent)) {
+      if (options.appendIfNoBlock) {
+        const prepended = [content.trim(), "", existingContent.trimStart()].join("\n");
+        return writeWithBackup(filePath, prepended, !!options.backup);
+      }
+      return { path: filePath, action: "skipped" };
+    }
+    const merged = insertManagedBlock(existingContent, options.managedContent);
+    return writeWithBackup(filePath, merged, !!options.backup);
+  }
+  const fileName = basename(filePath) ?? "";
+  const isManagedFile = fileName.startsWith(HATCH3R_PREFIX);
+  if (isManagedFile) {
+    return writeWithBackup(filePath, content, !!options.backup);
+  }
+  return { path: filePath, action: "skipped" };
+}
+
+// src/detect/repoAnalyzer.ts
+import { access as access2, readFile as readFile15, readdir as readdir2 } from "fs/promises";
+import { join as join15 } from "path";
+async function analyzeRepo(rootDir) {
+  const [languages, packageManager, isMonorepo, hasExistingAgents, existingTools] = await Promise.all([
+    detectLanguages(rootDir),
+    detectPackageManager(rootDir),
+    detectMonorepo(rootDir),
+    detectExistingAgents(rootDir),
+    detectExistingTools(rootDir)
+  ]);
+  return {
+    languages,
+    packageManager,
+    isMonorepo,
+    hasExistingAgents,
+    existingTools,
+    rootDir
+  };
+}
+async function detectLanguages(rootDir) {
+  const languages = [];
+  const indicators = {
+    typescript: ["tsconfig.json", "tsconfig.base.json"],
+    javascript: ["jsconfig.json"],
+    python: ["pyproject.toml", "setup.py", "requirements.txt", "Pipfile"],
+    rust: ["Cargo.toml"],
+    go: ["go.mod"],
+    java: ["pom.xml", "build.gradle"],
+    kotlin: ["build.gradle.kts"],
+    ruby: ["Gemfile"],
+    php: ["composer.json"],
+    swift: ["Package.swift"]
+  };
+  for (const [lang, files] of Object.entries(indicators)) {
+    for (const file of files) {
+      if (await pathExists(join15(rootDir, file))) {
+        languages.push(lang);
+        break;
+      }
+    }
+  }
+  try {
+    const rootEntries = await readdir2(rootDir);
+    if (rootEntries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
+      languages.push("csharp");
+    }
+  } catch {
+  }
+  if (languages.length === 0) {
+    languages.push("unknown");
+  }
+  return languages;
+}
+async function detectPackageManager(rootDir) {
+  if (await pathExists(join15(rootDir, "bun.lockb"))) return "bun";
+  if (await pathExists(join15(rootDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists(join15(rootDir, "yarn.lock"))) return "yarn";
+  if (await pathExists(join15(rootDir, "package-lock.json"))) return "npm";
+  if (await pathExists(join15(rootDir, "package.json"))) return "npm";
+  return "unknown";
+}
+async function detectMonorepo(rootDir) {
+  if (await pathExists(join15(rootDir, "pnpm-workspace.yaml"))) return true;
+  if (await pathExists(join15(rootDir, "lerna.json"))) return true;
+  if (await pathExists(join15(rootDir, "nx.json"))) return true;
+  if (await pathExists(join15(rootDir, "turbo.json"))) return true;
+  try {
+    const pkgJson = await readFile15(join15(rootDir, "package.json"), "utf-8");
+    const pkg = JSON.parse(pkgJson);
+    if (pkg.workspaces) return true;
+  } catch {
+  }
+  return false;
+}
+async function detectExistingAgents(rootDir) {
+  return pathExists(join15(rootDir, ".agents"));
+}
+async function detectExistingTools(rootDir) {
+  const tools = [];
+  if (await pathExists(join15(rootDir, ".cursor"))) tools.push("cursor");
+  if (await pathExists(join15(rootDir, ".github", "copilot-instructions.md")))
+    tools.push("copilot");
+  if (await pathExists(join15(rootDir, "CLAUDE.md")) || await pathExists(join15(rootDir, ".claude")))
+    tools.push("claude");
+  if (await pathExists(join15(rootDir, "opencode.json")) || await pathExists(join15(rootDir, "opencode.jsonc")))
+    tools.push("opencode");
+  if (await pathExists(join15(rootDir, ".windsurfrules")))
+    tools.push("windsurf");
+  if (await pathExists(join15(rootDir, ".amp")))
+    tools.push("amp");
+  if (await pathExists(join15(rootDir, ".codex"))) tools.push("codex");
+  if (await pathExists(join15(rootDir, ".gemini")) || await pathExists(join15(rootDir, "GEMINI.md"))) tools.push("gemini");
+  if (await pathExists(join15(rootDir, ".clinerules")) || await pathExists(join15(rootDir, ".roo")) || await pathExists(join15(rootDir, ".roomodes"))) tools.push("cline");
+  if (await pathExists(join15(rootDir, ".aider.conf.yml"))) tools.push("aider");
+  if (await pathExists(join15(rootDir, ".kiro"))) tools.push("kiro");
+  if (await pathExists(join15(rootDir, ".goosehints")) || await pathExists(join15(rootDir, ".goose"))) tools.push("goose");
+  if (await pathExists(join15(rootDir, ".rules"))) tools.push("zed");
+  return tools;
+}
+async function pathExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/env/mcpEnv.ts
+import { readFile as readFile16, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join16 } from "path";
+var ENV_MCP_FILE = ".env.mcp";
+var SOURCE_POSIX = "set -a && source .env.mcp && set +a";
+var SOURCE_POWERSHELL = "Get-Content .env.mcp | ForEach-Object { if ($_ -match '^\\s*([^#][^=]+)=(.*)$') { [Environment]::SetEnvironmentVariable($matches[1].Trim(), $matches[2].Trim(), 'Process') } }";
+function getSourceEnvMcpCommand() {
+  return process.platform === "win32" ? SOURCE_POWERSHELL : SOURCE_POSIX;
+}
+function getSourceEnvMcpDisclaimer() {
+  return [
+    "# Cursor / Claude Code: Source this file, then start or restart your editor (VS Code/Copilot auto-loads it).",
+    "# macOS/Linux (bash/zsh):",
+    `#   ${SOURCE_POSIX}`,
+    "# Windows (PowerShell):",
+    `#   ${SOURCE_POWERSHELL}`,
+    "# Windows (Git Bash): same as macOS/Linux",
+    ""
+  ].join("\n");
+}
+function collectRequiredEnvVars(servers) {
+  const seen = /* @__PURE__ */ new Set();
+  const vars = [];
+  for (const id of servers) {
+    const meta = AVAILABLE_MCP_SERVERS[id];
+    if (!meta?.requiresEnv) continue;
+    for (const name of meta.requiresEnv) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      const help = ENV_VAR_HELP[name];
+      vars.push({
+        name,
+        server: id,
+        comment: help?.comment ?? id,
+        url: help?.url ?? ""
+      });
+    }
+  }
+  return vars;
+}
+function generateEnvMcpContent(vars, existing = {}) {
+  if (vars.length === 0) return "";
+  const lines = [
+    "# hatch3r MCP secrets",
+    "# Fill in your values below. This file is gitignored \u2014 never commit it.",
+    "# Docs: https://github.com/hatch3r-dev/hatch3r/blob/main/docs/mcp-setup.md",
+    "",
+    getSourceEnvMcpDisclaimer()
+  ];
+  for (const v of vars) {
+    const urlPart = v.url ? ` \u2014 ${v.url}` : "";
+    lines.push(`# ${v.comment}${urlPart}`);
+    lines.push(`${v.name}=${existing[v.name] ?? ""}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function parseEnvFile(content) {
+  const result = {};
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const stripped = line.startsWith("export ") ? line.slice(7) : line;
+    const eqIdx = stripped.indexOf("=");
+    if (eqIdx < 1) continue;
+    const key = stripped.slice(0, eqIdx).trim();
+    let val = stripped.slice(eqIdx + 1).trim();
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      val = val.slice(1, -1);
+    }
+    result[key] = val;
+  }
+  return result;
+}
+async function ensureEnvMcp(rootDir, servers) {
+  const envPath = join16(rootDir, ENV_MCP_FILE);
+  const vars = collectRequiredEnvVars(servers);
+  if (vars.length === 0) {
+    return { action: "skipped", path: ENV_MCP_FILE, newVars: [] };
+  }
+  let existing = {};
+  let hadFile = false;
+  if (existsSync2(envPath)) {
+    hadFile = true;
+    const raw = await readFile16(envPath, "utf-8");
+    existing = parseEnvFile(raw);
+  }
+  const newVars = vars.filter((v) => !(v.name in existing)).map((v) => v.name);
+  if (hadFile && newVars.length === 0) {
+    return { action: "skipped", path: ENV_MCP_FILE, newVars: [] };
+  }
+  const content = generateEnvMcpContent(vars, existing);
+  await writeFile3(envPath, content, "utf-8");
+  return {
+    action: hadFile ? "updated" : "created",
+    path: ENV_MCP_FILE,
+    newVars
+  };
+}
+
+// src/cli/shared/paths.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname15, join as join17 } from "path";
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  while (dir !== dirname15(dir)) {
+    if (existsSync3(join17(dir, "package.json"))) return dir;
+    dir = dirname15(dir);
+  }
+  return startDir;
+}
+
+// src/cli/commands/init.ts
+var __dirname = dirname16(fileURLToPath(import.meta.url));
+var CONTENT_ROOT = findPackageRoot(__dirname);
+var CONTENT_DIRS = ["agents", "commands", "rules", "skills", "prompts", "github-agents", "mcp", "hooks"];
+var TOOL_CHOICES = [
+  { name: "Cursor", value: "cursor" },
+  { name: "GitHub Copilot", value: "copilot" },
+  { name: "Claude Code", value: "claude" },
+  { name: "OpenCode", value: "opencode" },
+  { name: "Windsurf", value: "windsurf" },
+  { name: "Amp", value: "amp" },
+  { name: "Codex CLI", value: "codex" },
+  { name: "Gemini CLI", value: "gemini" },
+  { name: "Cline / Roo Code", value: "cline" },
+  { name: "Aider", value: "aider" },
+  { name: "Kiro", value: "kiro" },
+  { name: "Goose", value: "goose" },
+  { name: "Zed", value: "zed" }
+];
+var FEATURE_CHOICES = [
+  { name: "Agents", value: "agents" },
+  { name: "Skills", value: "skills" },
+  { name: "Rules", value: "rules" },
+  { name: "Prompts", value: "prompts" },
+  { name: "Commands", value: "commands" },
+  { name: "MCP", value: "mcp" },
+  { name: "Hooks", value: "hooks" },
+  { name: "GitHub agents", value: "githubAgents" }
+];
+var MCP_CHOICES = Object.entries(AVAILABLE_MCP_SERVERS).map(([id, meta]) => ({
+  name: `${id}: ${meta.description}`,
+  value: id
+}));
+var DEFAULT_TOOLS = ["cursor"];
+var VALID_TOOLS = ["cursor", "copilot", "claude", "opencode", "windsurf", "amp", "codex", "gemini", "cline", "aider", "kiro", "goose", "zed"];
+var DEFAULT_FEATURE_KEYS = Object.keys(DEFAULT_FEATURES);
+var DEFAULT_MCP = ["github", "context7", "filesystem", "playwright", "brave-search"];
+function sanitizeInput(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "");
+}
+function parseGitRemote() {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], {
+      stdio: "pipe"
+    }).toString().trim();
+    const sshMatch = url.match(/[:\/]([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (sshMatch) {
+      return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    return { owner: "", repo: "" };
+  } catch {
+    return { owner: "", repo: "" };
+  }
+}
+function parseGitDefaultBranch() {
+  try {
+    const ref = execFileSync("git", ["rev-parse", "--abbrev-ref", "origin/HEAD"], {
+      stdio: "pipe"
+    }).toString().trim();
+    if (ref && ref.startsWith("origin/")) {
+      return ref.replace(/^origin\//, "");
+    }
+    return "main";
+  } catch {
+    return "main";
+  }
+}
+function toolDisplayName(tool) {
+  const names = {
+    cursor: "Cursor",
+    copilot: "GitHub Copilot",
+    claude: "Claude Code",
+    opencode: "OpenCode",
+    windsurf: "Windsurf",
+    amp: "Amp",
+    codex: "Codex CLI",
+    gemini: "Gemini CLI",
+    cline: "Cline",
+    aider: "Aider",
+    kiro: "Kiro",
+    goose: "Goose",
+    zed: "Zed"
+  };
+  return names[tool] ?? tool;
+}
+async function runInit(rootDir, owner, repo, defaultBranch, tools, features, mcpServers) {
+  const agentsDir = join18(rootDir, AGENTS_DIR);
+  const totalSteps = 4;
+  const s1 = createSpinner(step(1, totalSteps, "Creating canonical files..."));
+  s1.start();
+  await mkdir2(agentsDir, { recursive: true });
+  for (const dir of CONTENT_DIRS) {
+    const srcDir = join18(CONTENT_ROOT, dir);
+    const destDir = join18(agentsDir, dir);
+    try {
+      await cp(srcDir, destDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  await mkdir2(join18(agentsDir, "learnings"), { recursive: true });
+  const mcpPath = join18(agentsDir, "mcp", "mcp.json");
+  try {
+    const mcpRaw = await readFile17(mcpPath, "utf-8");
+    const mcpParsed = JSON.parse(mcpRaw);
+    if (mcpParsed.mcpServers) {
+      const selected = new Set(mcpServers);
+      const filtered = {};
+      for (const [name, server] of Object.entries(mcpParsed.mcpServers)) {
+        if (!selected.has(name)) continue;
+        const entry = { ...server };
+        delete entry._disabled;
+        filtered[name] = entry;
+      }
+      await writeFile4(
+        mcpPath,
+        JSON.stringify({ mcpServers: filtered }, null, 2) + "\n",
+        "utf-8"
+      );
+    }
+  } catch {
+  }
+  await writeFile4(join18(agentsDir, "AGENTS.md"), CANONICAL_AGENTS_MD, "utf-8");
+  s1.succeed(step(1, totalSteps, "Canonical files created"));
+  const s2 = createSpinner(step(2, totalSteps, "Writing manifest..."));
+  s2.start();
+  const manifest = createManifest({ owner, repo, defaultBranch, tools, features, mcpServers });
+  await writeManifest(rootDir, manifest);
+  s2.succeed(step(2, totalSteps, "Manifest written"));
+  const s3 = createSpinner(
+    step(3, totalSteps, `Generating ${tools.map(toolDisplayName).join(", ")} output...`)
+  );
+  s3.start();
+  await safeWriteFile(join18(rootDir, "AGENTS.md"), AGENTS_MD_FULL, {
+    managedContent: AGENTS_MD_INNER,
+    appendIfNoBlock: true
+  });
+  addManagedFile(manifest, "AGENTS.md");
+  for (const tool of tools) {
+    const adapter = getAdapter(tool);
+    try {
+      const outputs = await adapter.generate(agentsDir, manifest);
+      for (const out of outputs) {
+        await safeWriteFile(join18(rootDir, out.path), out.content, {
+          managedContent: out.managedContent,
+          appendIfNoBlock: true
+        });
+        addManagedFile(manifest, out.path);
+      }
+    } catch (err) {
+      s3.fail(step(3, totalSteps, `Failed to generate ${toolDisplayName(tool)} output`));
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+  s3.succeed(step(3, totalSteps, "Adapter output generated"));
+  const s4 = createSpinner(step(4, totalSteps, "Finalizing..."));
+  s4.start();
+  await writeManifest(rootDir, manifest);
+  let envResult;
+  if (features.mcp && mcpServers.length > 0) {
+    envResult = await ensureEnvMcp(rootDir, mcpServers);
+  }
+  s4.succeed(step(4, totalSteps, "Done"));
+  console.log();
+  const enabledFeatures = Object.entries(features).filter(([, v]) => v).map(([k]) => k);
+  const summaryLines = [
+    label("Tools", tools.map(toolDisplayName).join(", ")),
+    label("Features", enabledFeatures.join(", "))
+  ];
+  if (owner || repo) {
+    summaryLines.push(label("GitHub", `${owner}/${repo}`));
+  }
+  if (defaultBranch) {
+    summaryLines.push(label("Default branch", defaultBranch));
+  }
+  if (mcpServers.length > 0) {
+    summaryLines.push(label("MCP", mcpServers.join(", ")));
+  }
+  if (envResult && envResult.action !== "skipped") {
+    summaryLines.push(label("Secrets", `.env.mcp (fill in your API keys)`));
+  }
+  summaryLines.push("");
+  summaryLines.push(label("Canonical", `${AGENTS_DIR}/`));
+  summaryLines.push(label("Manifest", `${AGENTS_DIR}/hatch.json`));
+  printBox("Hatch complete", summaryLines, "success");
+  if (envResult && envResult.newVars.length > 0) {
+    warn(
+      `Add your secrets to .env.mcp: ${envResult.newVars.join(", ")}`
+    );
+    info(`Run this, then start or restart your editor: ${getSourceEnvMcpCommand()}`);
+  }
+}
+async function checkExisting(rootDir, skipPrompt) {
+  const hatchJsonPath = join18(rootDir, AGENTS_DIR, "hatch.json");
+  try {
+    await access3(hatchJsonPath);
+    if (!skipPrompt) {
+      const { proceed } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "proceed",
+          message: "Existing .agents/ found. This will overwrite managed files. Continue?",
+          default: false
+        }
+      ]);
+      if (!proceed) {
+        console.log(chalk15.dim("\n  Init cancelled.\n"));
+        process.exit(0);
+      }
+    }
+  } catch {
+  }
+}
+async function initCommand(opts = {}) {
+  printBanner();
+  const rootDir = process.cwd();
+  const detectSpinner = createSpinner("Detecting repository...");
+  detectSpinner.start();
+  const repoInfo = await analyzeRepo(rootDir);
+  const remote = parseGitRemote();
+  detectSpinner.succeed("Repository detected");
+  const detected = [];
+  if (repoInfo.languages.length > 0 && repoInfo.languages[0] !== "unknown") {
+    detected.push(...repoInfo.languages);
+  }
+  if (repoInfo.packageManager !== "unknown") {
+    detected.push(repoInfo.packageManager);
+  }
+  if (repoInfo.isMonorepo) detected.push("monorepo");
+  if (detected.length > 0) {
+    info(chalk15.dim(`Detected: ${detected.join(", ")}`));
+  }
+  if (opts.yes) {
+    const owner2 = sanitizeInput(remote.owner);
+    const repo2 = sanitizeInput(remote.repo);
+    let tools2;
+    if (opts.tools) {
+      const rawTools = opts.tools.split(",").map((t) => t.trim());
+      const invalid = rawTools.filter((t) => !VALID_TOOLS.includes(t));
+      if (invalid.length > 0) {
+        error(`Invalid tool(s): ${invalid.join(", ")}`);
+        console.log(chalk15.dim(`  Valid tools: ${VALID_TOOLS.join(", ")}`));
+        process.exit(1);
+      }
+      tools2 = rawTools;
+    } else if (repoInfo.existingTools.length > 0) {
+      tools2 = repoInfo.existingTools;
+    } else {
+      tools2 = DEFAULT_TOOLS;
+    }
+    const features2 = { ...DEFAULT_FEATURES };
+    const mcpServers2 = features2.mcp ? DEFAULT_MCP : [];
+    const defaultBranch2 = parseGitDefaultBranch();
+    await checkExisting(rootDir, true);
+    await runInit(rootDir, owner2, repo2, defaultBranch2, tools2, features2, mcpServers2);
+    return;
+  }
+  console.log();
+  const repoAnswers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "owner",
+      message: "GitHub owner (org or username):",
+      default: remote.owner || void 0
+    },
+    {
+      type: "input",
+      name: "repo",
+      message: "Repository name:",
+      default: remote.repo || void 0
+    }
+  ]);
+  const owner = sanitizeInput(repoAnswers.owner);
+  const repo = sanitizeInput(repoAnswers.repo);
+  const defaultBranchDefault = parseGitDefaultBranch();
+  const defaultBranchAnswers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "defaultBranch",
+      message: "Default branch (for checkout, PR base, release):",
+      default: defaultBranchDefault
+    }
+  ]);
+  const defaultBranch = defaultBranchAnswers.defaultBranch.trim() || defaultBranchDefault;
+  const toolDefaults = repoInfo.existingTools.length > 0 ? repoInfo.existingTools : DEFAULT_TOOLS;
+  const toolAnswers = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "tools",
+      message: "Select tools to configure:",
+      choices: TOOL_CHOICES,
+      default: toolDefaults
+    }
+  ]);
+  const tools = toolAnswers.tools.length > 0 ? toolAnswers.tools : DEFAULT_TOOLS;
+  const featureAnswers = await inquirer.prompt([
+    {
+      type: "checkbox",
+      name: "features",
+      message: "Select features:",
+      choices: FEATURE_CHOICES,
+      default: DEFAULT_FEATURE_KEYS
+    }
+  ]);
+  const selectedFeatures = featureAnswers.features;
+  const features = { ...DEFAULT_FEATURES };
+  for (const k of Object.keys(features)) {
+    features[k] = selectedFeatures.includes(k);
+  }
+  let mcpServers = [];
+  if (features.mcp) {
+    const mcpAnswers = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "mcp",
+        message: "Select MCP servers:",
+        choices: MCP_CHOICES,
+        default: DEFAULT_MCP
+      }
+    ]);
+    mcpServers = mcpAnswers.mcp ?? [];
+  }
+  await checkExisting(rootDir, false);
+  await runInit(rootDir, owner, repo, defaultBranch, tools, features, mcpServers);
+}
+
+// src/cli/commands/sync.ts
+import { mkdir as mkdir3, readFile as readFile18, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname17, join as join19 } from "path";
+import chalk16 from "chalk";
+async function syncCommand() {
+  printBanner(true);
+  const rootDir = process.cwd();
+  const agentsDir = join19(rootDir, AGENTS_DIR);
+  const manifest = await readManifest(rootDir);
+  if (!manifest) {
+    error("No .agents/hatch.json found.");
+    console.log(chalk16.dim("  Run `npx hatch3r init` to set up your project first.\n"));
+    process.exit(1);
+  }
+  const m = manifest;
+  const results = [];
+  const totalSteps = m.tools.length + 1;
+  let currentStep = 0;
+  const s1 = createSpinner(step(++currentStep, totalSteps, "Syncing AGENTS.md..."));
+  s1.start();
+  const agentsMdResult = await safeWriteFile(join19(rootDir, "AGENTS.md"), AGENTS_MD_FULL, {
+    managedContent: AGENTS_MD_INNER
+  });
+  results.push({ path: "AGENTS.md", action: agentsMdResult.action });
+  await writeFile5(join19(agentsDir, "AGENTS.md"), CANONICAL_AGENTS_MD, "utf-8");
+  results.push({ path: `${AGENTS_DIR}/AGENTS.md`, action: "updated" });
+  s1.succeed(step(currentStep, totalSteps, "AGENTS.md synced"));
+  for (const tool of m.tools) {
+    const s = createSpinner(step(++currentStep, totalSteps, `Generating ${tool} output...`));
+    s.start();
+    try {
+      const adapter = getAdapter(tool);
+      const outputs = await adapter.generate(agentsDir, m);
+      for (const out of outputs) {
+        const fullPath = join19(rootDir, out.path);
+        if (out.managedContent) {
+          const result = await safeWriteFile(fullPath, out.content, {
+            managedContent: out.managedContent
+          });
+          results.push({ path: out.path, action: result.action });
+        } else {
+          await mkdir3(dirname17(fullPath), { recursive: true });
+          let action;
+          try {
+            const existing = await readFile18(fullPath, "utf-8");
+            if (existing === out.content) {
+              action = "skipped";
+            } else {
+              await writeFile5(fullPath, out.content, "utf-8");
+              action = "updated";
+            }
+          } catch {
+            await writeFile5(fullPath, out.content, "utf-8");
+            action = "created";
+          }
+          results.push({ path: out.path, action });
+        }
+      }
+      s.succeed(step(currentStep, totalSteps, `${tool} output generated`));
+    } catch (err) {
+      s.fail(step(currentStep, totalSteps, `Failed to generate ${tool} output`));
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+  if (m.features.mcp && m.mcp.servers.length > 0) {
+    const envResult = await ensureEnvMcp(rootDir, m.mcp.servers);
+    if (envResult.action !== "skipped") {
+      results.push({ path: envResult.path, action: envResult.action });
+    }
+    if (envResult.newVars.length > 0) {
+      warn(
+        `New secrets needed in .env.mcp: ${envResult.newVars.join(", ")}`
+      );
+      info(`Run this, then start or restart your editor: ${getSourceEnvMcpCommand()}`);
+    }
+  }
+  console.log();
+  const icons = {
+    created: chalk16.green("+"),
+    updated: chalk16.yellow("~"),
+    skipped: chalk16.dim("=")
+  };
+  const summaryLines = results.map((r) => {
+    const icon = icons[r.action] ?? chalk16.dim(" ");
+    return `${icon} ${r.path} ${chalk16.dim(`(${r.action})`)}`;
+  });
+  printBox("Sync complete", summaryLines, "success");
+}
+
+// src/cli/commands/update.ts
+import { cp as cp2, mkdir as mkdir4, readdir as readdir3, readFile as readFile19, writeFile as writeFile6 } from "fs/promises";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname18, join as join20 } from "path";
+import chalk17 from "chalk";
+var __dirname2 = dirname18(fileURLToPath2(import.meta.url));
+var CONTENT_ROOT2 = findPackageRoot(__dirname2);
+var CONTENT_DIRS2 = ["agents", "commands", "rules", "skills", "prompts", "github-agents", "mcp", "hooks"];
+async function copyHatch3rFiles(srcDir, destDir, insideHatch3rDir = false) {
+  const copied = [];
+  const entries = await readdir3(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join20(srcDir, entry.name);
+    const destPath = join20(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await mkdir4(destPath, { recursive: true });
+      const subCopied = await copyHatch3rFiles(
+        srcPath,
+        destPath,
+        entry.name.startsWith(HATCH3R_PREFIX)
+      );
+      copied.push(...subCopied.map((p) => join20(entry.name, p)));
+    } else if (entry.name.startsWith(HATCH3R_PREFIX) || insideHatch3rDir) {
+      await mkdir4(dirname18(destPath), { recursive: true });
+      await cp2(srcPath, destPath, { force: true });
+      copied.push(entry.name);
+    }
+  }
+  return copied;
+}
+async function updateCommand(opts = {}) {
+  printBanner(true);
+  const rootDir = process.cwd();
+  const agentsDir = join20(rootDir, AGENTS_DIR);
+  const manifest = await readManifest(rootDir);
+  if (!manifest) {
+    error("No .agents/hatch.json found.");
+    console.log(chalk17.dim("  Run `npx hatch3r init` to set up your project first.\n"));
+    process.exit(1);
+  }
+  const m = manifest;
+  const currentVersion = m.hatch3rVersion;
+  const isUpToDate = currentVersion === HATCH3R_VERSION;
+  if (isUpToDate) {
+    info(`Already at hatch3r v${HATCH3R_VERSION}`);
+  } else {
+    info(`Updating from v${currentVersion} to v${HATCH3R_VERSION}`);
+  }
+  console.log();
+  const totalSteps = 3;
+  const s1 = createSpinner(step(1, totalSteps, "Updating canonical files..."));
+  s1.start();
+  const copied = [];
+  for (const dir of CONTENT_DIRS2) {
+    const srcDir = join20(CONTENT_ROOT2, dir);
+    try {
+      const dirCopied = await copyHatch3rFiles(srcDir, join20(agentsDir, dir));
+      copied.push(...dirCopied.map((p) => join20(dir, p)));
+    } catch {
+    }
+  }
+  await writeFile6(join20(agentsDir, "AGENTS.md"), CANONICAL_AGENTS_MD, "utf-8");
+  s1.succeed(step(1, totalSteps, `Updated ${copied.length} canonical files`));
+  const s2 = createSpinner(step(2, totalSteps, "Re-syncing adapter output..."));
+  s2.start();
+  for (const tool of m.tools) {
+    const adapter = getAdapter(tool);
+    try {
+      const outputs = await adapter.generate(agentsDir, m);
+      for (const out of outputs) {
+        const fullPath = join20(rootDir, out.path);
+        if (out.managedContent) {
+          await safeWriteFile(fullPath, out.content, {
+            managedContent: out.managedContent,
+            backup: opts.backup ?? true
+          });
+        } else {
+          await mkdir4(dirname18(fullPath), { recursive: true });
+          try {
+            const existing = await readFile19(fullPath, "utf-8");
+            if (existing !== out.content) {
+              await writeFile6(fullPath, out.content, "utf-8");
+            }
+          } catch {
+            await writeFile6(fullPath, out.content, "utf-8");
+          }
+        }
+      }
+    } catch (err) {
+      s2.fail(step(2, totalSteps, `Failed to generate ${tool} output`));
+      error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
+  s2.succeed(step(2, totalSteps, `Re-synced ${m.tools.length} tool(s)`));
+  const s3 = createSpinner(step(3, totalSteps, "Writing manifest..."));
+  s3.start();
+  m.hatch3rVersion = HATCH3R_VERSION;
+  await writeManifest(rootDir, m);
+  s3.succeed(step(3, totalSteps, "Manifest updated"));
+  console.log();
+  printBox("Update complete", [
+    label("Files", `${copied.length} canonical files updated`),
+    label("Tools", `${m.tools.length} tool(s) re-synced`),
+    label("Version", `v${HATCH3R_VERSION}`)
+  ], "success");
+}
+
+// src/cli/commands/validate.ts
+import { readdir as readdir4, readFile as readFile20, access as access4 } from "fs/promises";
+import { join as join21, posix } from "path";
+import chalk18 from "chalk";
+import { parse as parseYaml3 } from "yaml";
+async function validateCommand() {
+  printBanner(true);
+  const rootDir = process.cwd();
+  const agentsDir = join21(rootDir, AGENTS_DIR);
+  const result = { errors: [], warnings: [] };
+  const spinner = createSpinner("Validating .agents/ structure...");
+  spinner.start();
+  try {
+    await access4(agentsDir);
+  } catch {
+    spinner.fail("Validation failed");
+    error(".agents/ directory not found. Run `hatch3r init` first.");
+    console.log();
+    process.exit(1);
+  }
+  const manifest = await readManifest(rootDir);
+  if (!manifest) {
+    result.errors.push("Missing .agents/hatch.json manifest");
+  } else {
+    if (!manifest.version) result.errors.push("hatch.json: missing 'version' field");
+    if (!manifest.tools || manifest.tools.length === 0) result.warnings.push("hatch.json: no tools configured");
+    for (const managedFile of manifest.managedFiles ?? []) {
+      try {
+        await access4(join21(rootDir, managedFile));
+      } catch {
+        result.warnings.push(`Managed file missing from disk: ${managedFile}`);
+      }
+    }
+  }
+  const requiredDirs = ["agents", "skills", "rules"];
+  const optionalDirs = ["commands", "prompts", "mcp", "policy", "github-agents"];
+  for (const dir of requiredDirs) {
+    try {
+      await access4(join21(agentsDir, dir));
+    } catch {
+      result.errors.push(`Required directory missing: .agents/${dir}/`);
+    }
+  }
+  for (const dir of optionalDirs) {
+    try {
+      await access4(join21(agentsDir, dir));
+    } catch {
+      result.warnings.push(`Optional directory missing: .agents/${dir}/`);
+    }
+  }
+  for (const dir of [...requiredDirs, ...optionalDirs]) {
+    const dirPath = join21(agentsDir, dir);
+    try {
+      const entries = await readdir4(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+          const filePath = join21(dirPath, entry.name);
+          const content = await readFile20(filePath, "utf-8");
+          if (!content.startsWith("---")) {
+            result.warnings.push(`Missing frontmatter: .agents/${dir}/${entry.name}`);
+          } else {
+            const endIdx = content.indexOf("---", 3);
+            if (endIdx === -1) {
+              result.errors.push(`Invalid frontmatter (no closing ---): .agents/${dir}/${entry.name}`);
+            } else {
+              const frontmatter = content.slice(3, endIdx).trim();
+              const parsedFm = parseYaml3(frontmatter);
+              if (!parsedFm || typeof parsedFm !== "object" || !parsedFm.id) {
+                result.warnings.push(`Missing 'id' in frontmatter: .agents/${dir}/${entry.name}`);
+              }
+              if (!parsedFm || typeof parsedFm !== "object" || !parsedFm.type) {
+                result.warnings.push(`Missing 'type' in frontmatter: .agents/${dir}/${entry.name}`);
+              }
+            }
+          }
+        } else if (entry.isDirectory()) {
+          const skillPath = join21(dirPath, entry.name, "SKILL.md");
+          try {
+            await access4(skillPath);
+          } catch {
+            result.warnings.push(`Skill directory missing SKILL.md: .agents/${dir}/${entry.name}/`);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    await access4(join21(agentsDir, "AGENTS.md"));
+  } catch {
+    result.warnings.push("Missing .agents/AGENTS.md");
+  }
+  if (manifest) {
+    for (const managedFile of manifest.managedFiles ?? []) {
+      const fileName = posix.basename(managedFile) || "";
+      const isSharedFile = ["AGENTS.md", "CLAUDE.md", "copilot-instructions.md", ".windsurfrules", "mcp.json", "opencode.json", ".mcp.json", "copilot-setup-steps.yml", "settings.json"].some(
+        (sf) => fileName === sf || managedFile.endsWith(sf)
+      );
+      if (!isSharedFile && !fileName.startsWith(HATCH3R_PREFIX) && !fileName.startsWith(".")) {
+        result.warnings.push(`Managed file without hatch3r- prefix: ${managedFile}`);
+      }
+    }
+    if (manifest.features.hooks) {
+      const hooksDir = join21(agentsDir, "hooks");
+      try {
+        const hookFiles = await readdir4(hooksDir);
+        const mdHooks = hookFiles.filter((f) => f.endsWith(".md"));
+        if (mdHooks.length === 0) {
+          result.warnings.push("Hooks feature enabled but no hook definitions found in .agents/hooks/");
+        }
+        let agentFiles;
+        try {
+          const agentEntries = await readdir4(join21(agentsDir, "agents"));
+          agentFiles = new Set(agentEntries.filter((f) => f.endsWith(".md")));
+        } catch {
+        }
+        for (const hookFile of mdHooks) {
+          const hookContent = await readFile20(join21(hooksDir, hookFile), "utf-8");
+          if (!hookContent.startsWith("---")) {
+            result.warnings.push(`Hook missing frontmatter: .agents/hooks/${hookFile}`);
+            continue;
+          }
+          const endIdx = hookContent.indexOf("---", 3);
+          if (endIdx === -1) continue;
+          const fm = parseYaml3(hookContent.slice(3, endIdx).trim());
+          if (fm?.agent && typeof fm.agent === "string" && agentFiles) {
+            const expectedFile = `${HATCH3R_PREFIX}${fm.agent}.md`;
+            if (!agentFiles.has(expectedFile)) {
+              result.errors.push(`Hook "${hookFile}" references agent "${fm.agent}" but .agents/agents/${expectedFile} does not exist`);
+            }
+          }
+        }
+      } catch {
+        result.warnings.push("Hooks feature enabled but .agents/hooks/ directory not found");
+      }
+    }
+    if (manifest.features.mcp && manifest.mcp.servers.length > 0) {
+      const mcpPath = join21(agentsDir, "mcp", "mcp.json");
+      try {
+        const mcpContent = await readFile20(mcpPath, "utf-8");
+        const mcpParsed = JSON.parse(mcpContent);
+        if (!mcpParsed.mcpServers || typeof mcpParsed.mcpServers !== "object") {
+          result.errors.push("MCP config missing 'mcpServers' key");
+        }
+      } catch (err) {
+        if (err instanceof SyntaxError) {
+          result.errors.push("Invalid JSON in .agents/mcp/mcp.json");
+        } else {
+          result.warnings.push("MCP servers configured but .agents/mcp/mcp.json not found");
+        }
+      }
+    }
+    if (manifest.models) {
+      if (manifest.models.default && typeof manifest.models.default !== "string") {
+        result.errors.push("hatch.json: models.default must be a string");
+      }
+      if (manifest.models.agents) {
+        for (const [agentId, model] of Object.entries(manifest.models.agents)) {
+          if (typeof model !== "string") {
+            result.errors.push(`hatch.json: models.agents.${agentId} must be a string`);
+          }
+        }
+      }
+    }
+    const customizeDir = join21(rootDir, ".hatch3r", "agents");
+    try {
+      const customizeFiles = await readdir4(customizeDir);
+      for (const file of customizeFiles) {
+        if (file.endsWith(".customize.yaml")) {
+          const agentId = file.replace(".customize.yaml", "");
+          const agentFile = join21(agentsDir, "agents", `${agentId}.md`);
+          try {
+            await access4(agentFile);
+          } catch {
+            result.warnings.push(`Customization file for non-existent agent: .hatch3r/agents/${file}`);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  spinner.stop();
+  if (result.errors.length === 0 && result.warnings.length === 0) {
+    printBox("Validation", [chalk18.green("All checks passed")], "success");
+    return;
+  }
+  console.log();
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      error(err);
+    }
+    console.log();
+  }
+  if (result.warnings.length > 0) {
+    for (const w of result.warnings) {
+      warn(w);
+    }
+    console.log();
+  }
+  if (result.errors.length > 0) {
+    const summaryLines = [
+      `${chalk18.red("\u2716")} ${result.errors.length} error(s)`,
+      `${chalk18.yellow("\u26A0")} ${result.warnings.length} warning(s)`
+    ];
+    printBox("Validation failed", summaryLines, "error");
+    process.exit(1);
+  } else {
+    const summaryLines = [
+      `${chalk18.green("\u2714")} 0 errors`,
+      `${chalk18.yellow("\u26A0")} ${result.warnings.length} warning(s)`
+    ];
+    printBox("Validation passed", summaryLines, "success");
+  }
+}
+
+// src/cli/commands/status.ts
+import { readFile as readFile21 } from "fs/promises";
+import { join as join22 } from "path";
+import chalk19 from "chalk";
+async function statusCommand() {
+  printBanner(true);
+  const rootDir = process.cwd();
+  const agentsDir = join22(rootDir, AGENTS_DIR);
+  const manifest = await readManifest(rootDir);
+  if (!manifest) {
+    error("No .agents/hatch.json found.");
+    console.log(chalk19.dim("  Run `npx hatch3r init` to set up your project first.\n"));
+    process.exit(1);
+  }
+  const spinner = createSpinner("Checking sync status...");
+  spinner.start();
+  const stats = { synced: 0, drifted: 0, missing: 0 };
+  const fileLines = [];
+  for (const tool of manifest.tools) {
+    const adapter = getAdapter(tool);
+    const outputs = await adapter.generate(agentsDir, manifest);
+    fileLines.push(chalk19.bold(`${tool}:`));
+    for (const out of outputs) {
+      const destPath = join22(rootDir, out.path);
+      try {
+        const existing = await readFile21(destPath, "utf-8");
+        const existingBlock = extractManagedBlock(existing);
+        const expectedBlock = out.managedContent ?? extractManagedBlock(out.content);
+        if (existingBlock !== null && expectedBlock !== null ? existingBlock === expectedBlock : existing === out.content) {
+          fileLines.push(`  ${chalk19.green("=")} ${out.path}`);
+          stats.synced++;
+        } else {
+          fileLines.push(`  ${chalk19.yellow("~")} ${out.path} ${chalk19.dim("(drifted)")}`);
+          stats.drifted++;
+        }
+      } catch {
+        fileLines.push(`  ${chalk19.red("+")} ${out.path} ${chalk19.dim("(missing)")}`);
+        stats.missing++;
+      }
+    }
+  }
+  spinner.stop();
+  console.log();
+  for (const line of fileLines) {
+    console.log(`  ${line}`);
+  }
+  console.log();
+  const summaryLines = [
+    `${chalk19.green("=")} In sync: ${stats.synced}`
+  ];
+  if (stats.drifted > 0) {
+    summaryLines.push(`${chalk19.yellow("~")} Drifted: ${stats.drifted}`);
+  }
+  if (stats.missing > 0) {
+    summaryLines.push(`${chalk19.red("+")} Missing: ${stats.missing}`);
+  }
+  const style = stats.drifted > 0 || stats.missing > 0 ? "info" : "success";
+  printBox("Status", summaryLines, style);
+  if (stats.drifted > 0 || stats.missing > 0) {
+    info(`Run ${chalk19.bold("hatch3r sync")} to regenerate drifted/missing files.`);
+    console.log();
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("hatch3r").description(
+  "Battle-tested agentic coding setup framework. Crack the egg. Hatch better agents."
+).version(HATCH3R_VERSION);
+program.command("init").description("Install a complete agent setup into the current repo").option(
+  "--tools <tools>",
+  "Comma-separated tools (cursor,copilot,claude,opencode,windsurf,amp,codex,gemini,cline)"
+).option("--yes", "Skip interactive prompts, use defaults").action(initCommand);
+program.command("sync").description("Re-generate tool outputs from canonical .agents/ state").action(syncCommand);
+program.command("status").description("Check sync status between canonical .agents/ and generated files").action(statusCommand);
+program.command("update").description("Pull latest hatch3r templates with safe merge").option("--backup", "Create backups before overwriting", true).action(updateCommand);
+program.command("validate").description("Validate the canonical .agents/ structure").action(validateCommand);
+program.command("add [pack]").description("Install a community pack (coming soon)").action(addCommand);
+program.parse();