bmalph 2.2.1 → 2.4.0

package/README.md

@@ -25,13 +25,32 @@ bmalph provides:
 - `bmalph init` — Install both systems
 - `bmalph upgrade` — Update to latest versions
 - `bmalph doctor` — Check installation health
-- `/bmalph-implement` — Transition from BMAD to Ralph
+- `bmalph implement` — Transition from BMAD to Ralph
+
+## Supported Platforms
+
+bmalph works with multiple AI coding assistants. Each platform gets BMAD planning (Phases 1-3). The Ralph autonomous loop (Phase 4) requires a CLI-based platform.
+
+| Platform       | ID            | Tier              | Instructions File                 | Commands                      |
+| -------------- | ------------- | ----------------- | --------------------------------- | ----------------------------- |
+| Claude Code    | `claude-code` | full              | `CLAUDE.md`                       | `.claude/commands/` directory |
+| OpenAI Codex   | `codex`       | full              | `AGENTS.md`                       | Inline in instructions file   |
+| Cursor         | `cursor`      | instructions-only | `.cursor/rules/bmad.mdc`          | None                          |
+| Windsurf       | `windsurf`    | instructions-only | `.windsurf/rules/bmad.md`         | None                          |
+| GitHub Copilot | `copilot`     | instructions-only | `.github/copilot-instructions.md` | None                          |
+| Aider          | `aider`       | instructions-only | `CONVENTIONS.md`                  | None                          |
+
+**Tiers:**
+
+- **full** — Phases 1-4. BMAD planning + Ralph autonomous implementation loop.
+- **instructions-only** — Phases 1-3. BMAD planning only. Ralph is not available.
 
 ## Prerequisites
 
 - Node.js 20+
 - Bash (WSL or Git Bash on Windows)
-- Claude Code (`claude` in PATH) — needed for Ralph loop
+- A supported AI coding platform (see table above)
+- For Ralph loop (Phase 4): Claude Code (`claude`) or Codex CLI (`codex`) in PATH
 
 ## Installation
 
@@ -44,9 +63,9 @@ npm install -g bmalph
 ```bash
 cd my-project
 bmalph init --name my-project
-# Use /bmalph slash command in Claude Code to navigate phases
-# ... work through BMAD phases 1-3 ...
-# Use /bmalph-implement to transition and start Ralph
+
+# To target a specific platform, add --platform (e.g. codex, cursor, windsurf)
+# Without --platform, bmalph auto-detects or prompts interactively
 ```
 
 ## Workflow
@@ -58,17 +77,27 @@ cd my-project
 bmalph init
 ```
 
+**Platform resolution:** `--platform` flag > auto-detect from project markers > interactive prompt > default `claude-code`
+
 This installs:
 
 - `_bmad/` — BMAD agents and workflows
-- `.ralph/` — Ralph loop, libs, templates
-- `bmalph/` — State management (config.json)
-- Updates `CLAUDE.md` with BMAD workflow instructions
-- Installs slash commands in `.claude/commands/`
+- `.ralph/` — Ralph loop, libs, templates (drivers for claude-code and codex only)
+- `bmalph/` — State management (config.json, stores selected platform)
+- Updates the platform's instructions file with BMAD workflow instructions (e.g. `CLAUDE.md`, `AGENTS.md`, `.cursor/rules/bmad.mdc`)
+- Installs slash commands for supported platforms (Claude Code: `.claude/commands/` directory; Codex: inline in `AGENTS.md`; other platforms: commands not installed)
+
+### Migrating from standalone BMAD
+
+If you already have BMAD installed (a `_bmad/` directory), `bmalph init` works as a migration path:
+
+- `_bmad/` (framework files) will be replaced with the bmalph-managed version
+- `_bmad-output/` (your planning artifacts: PRDs, architecture, stories) is not touched
+- If you've customized framework files inside `_bmad/`, commit first so you can review changes with `git diff`
 
 ### Step 2: Plan with BMAD (Phases 1-3)
 
-Work interactively in Claude Code with BMAD agents. Use the `/bmalph` slash command to see your current phase, available commands, and advance phases.
+Work interactively with BMAD agents in your AI coding assistant. On Claude Code, use the `/bmalph` slash command to see your current phase and available commands. On other platforms, ask the agent about BMAD phases or run `bmalph status` in terminal.
 
 | Phase         | Agent            | Commands           |
 | ------------- | ---------------- | ------------------ |
@@ -124,7 +153,9 @@ Available in any phase for supporting tasks:
 
 ### Step 3: Implement with Ralph (Phase 4)
 
-Use the `/bmalph-implement` slash command in Claude Code.
+> **Note:** Ralph is only available on **full** tier platforms (Claude Code, OpenAI Codex). Instructions-only platforms (Cursor, Windsurf, Copilot, Aider) support Phases 1-3 only.
+
+Run `bmalph implement` from the terminal, or use the `/bmalph-implement` slash command in Claude Code.
 
 This transitions your BMAD artifacts into Ralph's format:
 
@@ -133,10 +164,14 @@ This transitions your BMAD artifacts into Ralph's format:
 3. Copies specs to `.ralph/specs/` with changelog tracking
 4. Instructs you to start the Ralph autonomous loop
 
-Then start Ralph:
+Then start Ralph using the driver for your platform:
 
 ```bash
-bash .ralph/ralph_loop.sh
+# Claude Code
+bash .ralph/drivers/claude-code.sh
+
+# OpenAI Codex
+bash .ralph/drivers/codex.sh
 ```
 
 Ralph picks stories one by one, implements with TDD, and commits. The loop stops when all stories are done or the circuit breaker triggers.
@@ -146,12 +181,12 @@ Ralph picks stories one by one, implements with TDD, and commits. The loop stops
 bmalph supports iterative development cycles:
 
 ```
-BMAD (Epic 1) → /bmalph-implement → Ralph works on Epic 1
+BMAD (Epic 1) → bmalph implement → Ralph works on Epic 1
      ↓
-BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
+BMAD (add Epic 2) → bmalph implement → Ralph sees changes + picks up Epic 2
 ```
 
-**Smart Merge**: When you run `/bmalph-implement` again after Ralph has made progress:
+**Smart Merge**: When you run `bmalph implement` again after Ralph has made progress:
 
 - Completed stories (`[x]`) are preserved in the new fix_plan
 - New stories from BMAD are added as pending (`[ ]`)
@@ -167,6 +202,7 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 | `bmalph doctor`        | Check installation health                           |
 | `bmalph check-updates` | Check if bundled BMAD/Ralph versions are up to date |
 | `bmalph status`        | Show current project status and phase               |
+| `bmalph implement`     | Transition BMAD planning artifacts to Ralph format  |
 
 ### Global options
 
@@ -181,10 +217,29 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 
 ### init options
 
-| Flag                       | Description         | Default        |
-| -------------------------- | ------------------- | -------------- |
-| `-n, --name <name>`        | Project name        | directory name |
-| `-d, --description <desc>` | Project description | (prompted)     |
+| Flag                       | Description                                                                        | Default        |
+| -------------------------- | ---------------------------------------------------------------------------------- | -------------- |
+| `-n, --name <name>`        | Project name                                                                       | directory name |
+| `-d, --description <desc>` | Project description                                                                | (prompted)     |
+| `--platform <id>`          | Target platform (`claude-code`, `codex`, `cursor`, `windsurf`, `copilot`, `aider`) | auto-detect    |
+
+### implement options
+
+| Flag      | Description                           |
+| --------- | ------------------------------------- |
+| `--force` | Override pre-flight validation errors |
+
+### check-updates options
+
+| Flag     | Description    |
+| -------- | -------------- |
+| `--json` | Output as JSON |
+
+### status options
+
+| Flag     | Description    |
+| -------- | -------------- |
+| `--json` | Output as JSON |
 
 ### upgrade options
 
@@ -195,7 +250,13 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 
 ## Slash Commands
 
-bmalph installs 47 BMAD slash commands. Key commands:
+bmalph installs 50 slash commands (45 BMAD + 5 bmalph). Command delivery varies by platform:
+
+- **Claude Code** — installed as files in `.claude/commands/` (invoke with `/command-name`)
+- **OpenAI Codex** — inlined in `AGENTS.md` (reference agents by name)
+- **Cursor, Windsurf, Copilot, Aider** — not delivered as slash commands; use agents by name in chat
+
+Key commands (Claude Code syntax):
 
 | Command                 | Description                         |
 | ----------------------- | ----------------------------------- |
@@ -218,7 +279,7 @@ For full list, run `/bmad-help` in Claude Code.
 
 ### Transition to Ralph
 
-Use `/bmalph-implement` to transition from BMAD planning to Ralph implementation.
+Use `bmalph implement` (or `/bmalph-implement` in Claude Code) to transition from BMAD planning to Ralph implementation.
 
 ## Project Structure (after init)
 
@@ -226,44 +287,64 @@ Use `/bmalph-implement` to transition from BMAD planning to Ralph implementation
 project/
 ├── _bmad/                     # BMAD agents, workflows, core
 │   ├── _config/               # Generated configuration
-│   │   └── config.yaml        # Platform config
+│   │   ├── config.yaml        # Platform config
+│   │   ├── task-manifest.csv  # Combined task manifest
+│   │   ├── workflow-manifest.csv # Combined workflow manifest
+│   │   └── bmad-help.csv      # Combined help manifest
 │   ├── core/
 │   │   ├── agents/            # Master agent
 │   │   ├── tasks/             # Workflow tasks
-│   │   └── workflows/         # Brainstorming, party-mode, etc.
+│   │   ├── workflows/         # Brainstorming, party-mode, etc.
+│   │   ├── module.yaml        # Core module metadata
+│   │   └── module-help.csv    # Core module help entries
 │   └── bmm/
 │       ├── agents/            # Analyst, PM, Architect, Dev, QA, etc.
+│       ├── data/              # Templates (project-context-template.md)
 │       ├── workflows/         # Phase 1-4 workflows
-│       └── teams/             # Agent team definitions
+│       ├── teams/             # Agent team definitions
+│       ├── module.yaml        # BMM module metadata
+│       └── module-help.csv    # BMM module help entries
 ├── _bmad-output/              # BMAD planning artifacts (generated)
 │   ├── planning-artifacts/    # PRD, architecture, stories
 │   ├── implementation-artifacts/ # Sprint plans (optional)
 │   └── brainstorming/         # Brainstorm sessions (optional)
-├── .ralph/                    # Ralph autonomous loop
+├── .ralph/                    # Ralph autonomous loop (drivers for claude-code and codex only)
 │   ├── ralph_loop.sh          # Main loop script
 │   ├── ralph_import.sh        # Import requirements into Ralph
 │   ├── ralph_monitor.sh       # Monitor loop progress
 │   ├── .ralphrc               # Ralph configuration
 │   ├── RALPH-REFERENCE.md     # Ralph usage reference
-│   ├── lib/                   # Circuit breaker, response analyzer
+│   ├── drivers/               # Platform driver scripts
+│   │   ├── claude-code.sh     # Claude Code driver (uses `claude`)
+│   │   └── codex.sh           # OpenAI Codex driver (uses `codex exec`)
+│   ├── lib/                   # Shell libraries
+│   ├── docs/generated/        # Generated documentation
 │   ├── specs/                 # Copied from _bmad-output during transition
 │   ├── logs/                  # Loop execution logs
 │   ├── PROMPT.md              # Iteration prompt template
-│   ├── PROJECT_CONTEXT.md     # Extracted project context (after /bmalph-implement)
-│   ├── SPECS_CHANGELOG.md     # Spec diff since last run (after /bmalph-implement)
+│   ├── PROJECT_CONTEXT.md     # Extracted project context (after bmalph implement)
+│   ├── SPECS_CHANGELOG.md     # Spec diff since last run (after bmalph implement)
+│   ├── SPECS_INDEX.md         # Prioritized spec file index (after bmalph implement)
 │   ├── @AGENT.md              # Agent build instructions
-│   └── @fix_plan.md           # Generated task list (after /bmalph-implement)
+│   └── @fix_plan.md           # Generated task list (after bmalph implement)
 ├── bmalph/                    # State management
-│   ├── config.json            # Project config (name, description)
+│   ├── config.json            # Project config (name, description, platform)
 │   └── state/                 # Phase tracking data
-├── .claude/
-│   └── commands/              # Slash commands for Claude Code
-└── CLAUDE.md                  # Updated with BMAD instructions
+├── .claude/                   # Claude Code specific
+│   └── commands/              # Slash commands (claude-code only)
+└── <instructions file>        # Varies by platform (see Supported Platforms)
 ```
 
+The instructions file and command directory depend on the configured platform. See the [Supported Platforms](#supported-platforms) table for details.
+
 ## How Ralph Works
 
-Ralph is a bash loop that spawns fresh Claude Code instances:
+Ralph is a bash loop that spawns fresh AI coding sessions using a **platform driver** matching the configured platform:
+
+- **Claude Code driver** — invokes `claude` with `--allowedTools` and session resume
+- **Codex driver** — invokes `codex exec` with `--sandbox workspace-write`
+
+Each iteration:
 
 1. Pick the next unchecked story from `@fix_plan.md`
 2. Implement with TDD (tests first, then code)
@@ -304,8 +385,8 @@ wsl --install
 If you get permission errors:
 
 ```bash
-# Unix/Mac: Make ralph_loop.sh executable
-chmod +x .ralph/ralph_loop.sh
+# Unix/Mac: Make driver scripts executable
+chmod +x .ralph/drivers/*.sh
 
 # Check file ownership
 ls -la .ralph/
@@ -313,12 +394,14 @@ ls -la .ralph/
 
 ### Common Issues
 
-| Scenario                     | Solution                                                  |
-| ---------------------------- | --------------------------------------------------------- |
-| Commands fail before init    | Run `bmalph init` first                                   |
-| Transition finds no stories  | Create stories in Phase 3 with `/create-epics-stories`    |
-| Ralph stops mid-loop         | Circuit breaker detected stagnation. Check `.ralph/logs/` |
-| Doctor reports version drift | Run `bmalph upgrade` to update bundled assets             |
+| Scenario                      | Solution                                                       |
+| ----------------------------- | -------------------------------------------------------------- |
+| Commands fail before init     | Run `bmalph init` first                                        |
+| Transition finds no stories   | Create stories in Phase 3 with `/create-epics-stories`         |
+| Ralph stops mid-loop          | Circuit breaker detected stagnation. Check `.ralph/logs/`      |
+| Doctor reports version drift  | Run `bmalph upgrade` to update bundled assets                  |
+| Wrong platform detected       | Re-run `bmalph init --platform <id>` with the correct platform |
+| Ralph unavailable on platform | Ralph requires a full tier platform (claude-code or codex)     |
 
 ### Reset Installation
 
@@ -326,8 +409,16 @@ If something goes wrong, you can manually reset:
 
 ```bash
 # Remove bmalph directories (preserves your project code)
-rm -rf _bmad .ralph bmalph .claude/commands/
-# Note: manually remove the bmalph section from CLAUDE.md and .gitignore entries
+rm -rf _bmad .ralph bmalph
+
+# Also remove platform-specific files:
+# Claude Code:  rm -rf .claude/commands/  and remove bmalph section from CLAUDE.md
+# Codex:        remove bmalph sections from AGENTS.md
+# Cursor:       rm .cursor/rules/bmad.mdc
+# Windsurf:     rm .windsurf/rules/bmad.md
+# Copilot:      remove bmalph sections from .github/copilot-instructions.md
+# Aider:        remove bmalph sections from CONVENTIONS.md
+# See the Supported Platforms table for your platform's files.
 
 # Reinitialize
 bmalph init
@@ -338,12 +429,17 @@ bmalph init
 ### Initialize a new project
 
 ```bash
-# Interactive mode (prompts for name/description)
+# Interactive mode (prompts for name/description, auto-detects platform)
 bmalph init
 
 # Non-interactive mode
 bmalph init --name my-app --description "My awesome app"
 
+# Specify platform explicitly
+bmalph init --name my-app --platform codex
+bmalph init --name my-app --platform cursor
+bmalph init --name my-app --platform windsurf
+
 # Preview what would be created
 bmalph init --dry-run
 ```
@@ -370,6 +466,8 @@ bmalph upgrade --dry-run
 
 ### After init: Next steps
 
+**Claude Code:**
+
 ```bash
 # 1. Open Claude Code in your project
 claude
@@ -383,10 +481,26 @@ claude
 #    Phase 3: /architect → create architecture and stories
 
 # 4. Transition to Ralph
-#    Use /bmalph-implement to generate @fix_plan.md
+#    Run: bmalph implement
 
 # 5. Start autonomous implementation
-bash .ralph/ralph_loop.sh
+bash .ralph/drivers/claude-code.sh
+```
+
+**Other platforms:**
+
+```bash
+# 1. Open your project in your AI coding assistant
+
+# 2. Ask the agent about BMAD phases to start planning
+#    Or check status from terminal: bmalph status
+
+# 3. Reference BMAD agents by name (analyst, pm, architect)
+#    Follow phases: Analysis → Planning → Solutioning
+
+# 4. For full tier platforms (Codex), transition to Ralph:
+#    Run: bmalph implement
+bash .ralph/drivers/codex.sh
 ```
 
 ## Contributing

package/dist/cli.js

@@ -6,6 +6,8 @@ import { upgradeCommand } from "./commands/upgrade.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { checkUpdatesCommand } from "./commands/check-updates.js";
 import { statusCommand } from "./commands/status.js";
+import { implementCommand } from "./commands/implement.js";
+import { resetCommand } from "./commands/reset.js";
 import { setVerbose, setQuiet } from "./utils/logger.js";
 import { getPackageVersion } from "./installer.js";
 import { isEnoent } from "./utils/errors.js";
@@ -55,6 +57,7 @@ program
     .description("Initialize bmalph in the current project")
     .option("-n, --name <name>", "Project name")
     .option("-d, --description <desc>", "Project description")
+    .option("--platform <id>", "Target platform (claude-code, codex, cursor, windsurf, copilot, aider)")
     .option("--dry-run", "Preview changes without writing files")
     .action(async (opts) => initCommand({ ...opts, projectDir: await resolveAndValidateProjectDir() }));
 program
@@ -78,4 +81,15 @@ program
     .description("Show current project status and phase")
     .option("--json", "Output as JSON")
     .action(async (opts) => statusCommand({ ...opts, projectDir: await resolveAndValidateProjectDir() }));
+program
+    .command("implement")
+    .description("Transition BMAD planning artifacts to Ralph implementation format")
+    .option("--force", "Override pre-flight validation errors")
+    .action(async (opts) => implementCommand({ ...opts, projectDir: await resolveAndValidateProjectDir() }));
+program
+    .command("reset")
+    .description("Remove all bmalph files from the project")
+    .option("--dry-run", "Preview changes without removing files")
+    .option("--force", "Skip confirmation prompt")
+    .action(async (opts) => resetCommand({ ...opts, projectDir: await resolveAndValidateProjectDir() }));
 void program.parseAsync();

package/dist/commands/doctor.d.ts

@@ -1,3 +1,4 @@
+import type { Platform } from "../platform/types.js";
 /**
  * Result of a single doctor check.
  */
@@ -32,8 +33,19 @@ interface DoctorResult {
 }
 export declare function runDoctor(options: DoctorOptions): Promise<DoctorResult>;
 /**
- * Registry of all doctor checks in execution order.
- * Each check has a unique ID and a run function that takes a project directory.
+ * Build the full check registry for a given platform.
+ * Core checks + platform doctor checks + trailing checks.
+ */
+export declare function buildCheckRegistry(platform: Platform): CheckDefinition[];
+/**
+ * Static registry for backward compatibility with existing tests.
+ * Uses claude-code platform checks (slash-command + claude-md).
+ *
+ * Note: The check ids here ("slash-command", "claude-md") intentionally differ
+ * from the live buildCheckRegistry path which uses platform-provided ids
+ * ("instructions-file"). This is for test backward compatibility only.
+ *
+ * @deprecated Use `buildCheckRegistry(platform)` for platform-aware checks.
  */
 export declare const CHECK_REGISTRY: CheckDefinition[];
 export {};

package/dist/commands/doctor.js

@@ -9,6 +9,7 @@ import { checkUpstream, getSkipReason } from "../utils/github.js";
 import { isEnoent, formatError, withErrorHandling } from "../utils/errors.js";
 import { validateCircuitBreakerState, validateRalphSession, validateRalphApiStatus, } from "../utils/validate.js";
 import { SESSION_AGE_WARNING_MS, API_USAGE_WARNING_PERCENT, CONFIG_FILE, RALPH_STATUS_FILE, } from "../utils/constants.js";
+import { resolveProjectPlatform } from "../platform/resolve.js";
 export async function doctorCommand(options) {
     await withErrorHandling(async () => {
         const { failed } = await runDoctor(options);
@@ -19,8 +20,12 @@ export async function doctorCommand(options) {
 }
 export async function runDoctor(options) {
     const projectDir = options.projectDir;
-    // Run all checks from the registry
-    const results = await Promise.all(CHECK_REGISTRY.map((check) => check.run(projectDir)));
+    // Resolve platform for this project
+    const platform = await resolveProjectPlatform(projectDir);
+    // Build the check list: core checks + platform-specific checks
+    const checks = buildCheckRegistry(platform);
+    // Run all checks
+    const results = await Promise.all(checks.map((check) => check.run(projectDir)));
     // Output
     const passed = results.filter((r) => r.passed).length;
     const failed = results.filter((r) => !r.passed).length;
@@ -59,10 +64,10 @@ export async function runDoctor(options) {
     }
     return { passed, failed };
 }
-async function checkBashAvailable() {
+async function checkCommandAvailable(command) {
     const { execSync } = await import("child_process");
     try {
-        const cmd = process.platform === "win32" ? "where bash" : "which bash";
+        const cmd = process.platform === "win32" ? `where ${command}` : `which ${command}`;
         execSync(cmd, { stdio: "ignore" });
         return true;
     }
@@ -71,7 +76,7 @@ async function checkBashAvailable() {
     }
 }
 // =============================================================================
-// Check functions - each conforms to CheckFunction signature
+// Core check functions - platform-independent
 // =============================================================================
 async function checkNodeVersion(_projectDir) {
     const major = parseInt(process.versions.node.split(".")[0]);
@@ -83,18 +88,33 @@ async function checkNodeVersion(_projectDir) {
     };
 }
 async function checkBash(_projectDir) {
-    const bashAvailable = await checkBashAvailable();
+    const available = await checkCommandAvailable("bash");
     return {
         label: "bash available",
-        passed: bashAvailable,
-        detail: bashAvailable ? undefined : "bash not found in PATH",
-        hint: bashAvailable
+        passed: available,
+        detail: available ? undefined : "bash not found in PATH",
+        hint: available
             ? undefined
             : process.platform === "win32"
                 ? "Install Git Bash or WSL: https://git-scm.com/downloads"
                 : "Install bash via your package manager (apt, brew, etc.)",
     };
 }
+async function checkJq(_projectDir) {
+    const available = await checkCommandAvailable("jq");
+    return {
+        label: "jq available",
+        passed: available,
+        detail: available ? undefined : "jq not found in PATH",
+        hint: available
+            ? undefined
+            : process.platform === "win32"
+                ? "Install jq: choco install jq (or: winget install jqlang.jq)"
+                : process.platform === "darwin"
+                    ? "Install jq: brew install jq"
+                    : "Install jq: sudo apt-get install jq",
+    };
+}
 async function checkBmadDir(projectDir) {
     return checkDir(join(projectDir, "_bmad"), "_bmad/ directory present", "Run: bmalph init");
 }
@@ -104,9 +124,6 @@ async function checkRalphLoop(projectDir) {
 async function checkRalphLib(projectDir) {
     return checkDir(join(projectDir, ".ralph/lib"), ".ralph/lib/ directory present", "Run: bmalph upgrade");
 }
-async function checkSlashCommand(projectDir) {
-    return checkFileExists(join(projectDir, ".claude/commands/bmalph.md"), ".claude/commands/bmalph.md present", "Run: bmalph init");
-}
 async function checkConfig(projectDir) {
     const label = "bmalph/config.json exists and valid";
     const hint = "Run: bmalph init";
@@ -135,12 +152,6 @@ async function checkDir(dirPath, label, hint) {
         return { label, passed: false, detail: `error: ${formatError(err)}`, hint };
     }
 }
-async function checkFileExists(filePath, label, hint) {
-    if (await exists(filePath)) {
-        return { label, passed: true };
-    }
-    return { label, passed: false, detail: "not found", hint };
-}
 async function checkFileHasContent(filePath, label, hint) {
     try {
         const content = await readFile(filePath, "utf-8");
@@ -153,23 +164,6 @@ async function checkFileHasContent(filePath, label, hint) {
         return { label, passed: false, detail: `error: ${formatError(err)}`, hint };
     }
 }
-async function checkClaudeMd(projectDir) {
-    const label = "CLAUDE.md contains BMAD snippet";
-    const hint = "Run: bmalph init";
-    try {
-        const content = await readFile(join(projectDir, "CLAUDE.md"), "utf-8");
-        if (content.includes("BMAD-METHOD Integration")) {
-            return { label, passed: true };
-        }
-        return { label, passed: false, detail: "missing BMAD-METHOD Integration section", hint };
-    }
-    catch (err) {
-        if (isEnoent(err)) {
-            return { label, passed: false, detail: "CLAUDE.md not found", hint };
-        }
-        return { label, passed: false, detail: `error: ${formatError(err)}`, hint };
-    }
-}
 async function checkGitignore(projectDir) {
     const label = ".gitignore has required entries";
     const required = [".ralph/logs/", "_bmad-output/"];
@@ -412,21 +406,24 @@ async function checkUpstreamGitHubStatus(_projectDir) {
     }
 }
 // =============================================================================
-// Check Registry - defines all checks in execution order
+// Check Registry - core checks + platform-specific checks
 // =============================================================================
 /**
- * Registry of all doctor checks in execution order.
- * Each check has a unique ID and a run function that takes a project directory.
+ * Core checks that apply to every platform.
  */
-export const CHECK_REGISTRY = [
+const CORE_CHECKS = [
     { id: "node-version", run: checkNodeVersion },
     { id: "bash-available", run: checkBash },
+    { id: "jq-available", run: checkJq },
     { id: "config-valid", run: checkConfig },
     { id: "bmad-dir", run: checkBmadDir },
     { id: "ralph-loop", run: checkRalphLoop },
     { id: "ralph-lib", run: checkRalphLib },
-    { id: "slash-command", run: checkSlashCommand },
-    { id: "claude-md", run: checkClaudeMd },
+];
+/**
+ * Checks that run after platform-specific checks.
+ */
+const TRAILING_CHECKS = [
     { id: "gitignore", run: checkGitignore },
     { id: "version-marker", run: checkVersionMarker },
     { id: "upstream-versions", run: checkUpstreamVersions },
@@ -435,3 +432,70 @@ export const CHECK_REGISTRY = [
     { id: "api-calls", run: checkApiCalls },
     { id: "upstream-github", run: checkUpstreamGitHubStatus },
 ];
+/**
+ * Build the full check registry for a given platform.
+ * Core checks + platform doctor checks + trailing checks.
+ */
+export function buildCheckRegistry(platform) {
+    const platformChecks = platform.getDoctorChecks().map((pc) => ({
+        id: pc.id,
+        run: async (projectDir) => {
+            const result = await pc.check(projectDir);
+            return {
+                label: pc.label,
+                passed: result.passed,
+                detail: result.detail,
+                hint: result.hint,
+            };
+        },
+    }));
+    return [...CORE_CHECKS, ...platformChecks, ...TRAILING_CHECKS];
+}
+/**
+ * Static registry for backward compatibility with existing tests.
+ * Uses claude-code platform checks (slash-command + claude-md).
+ *
+ * Note: The check ids here ("slash-command", "claude-md") intentionally differ
+ * from the live buildCheckRegistry path which uses platform-provided ids
+ * ("instructions-file"). This is for test backward compatibility only.
+ *
+ * @deprecated Use `buildCheckRegistry(platform)` for platform-aware checks.
+ */
+export const CHECK_REGISTRY = (() => {
+    // Inline claude-code platform checks to avoid async import at module level
+    const slashCommandCheck = {
+        id: "slash-command",
+        run: async (projectDir) => {
+            if (await exists(join(projectDir, ".claude/commands/bmalph.md"))) {
+                return { label: ".claude/commands/bmalph.md present", passed: true };
+            }
+            return {
+                label: ".claude/commands/bmalph.md present",
+                passed: false,
+                detail: "not found",
+                hint: "Run: bmalph init",
+            };
+        },
+    };
+    const claudeMdCheck = {
+        id: "claude-md",
+        run: async (projectDir) => {
+            const label = "CLAUDE.md contains BMAD snippet";
+            const hint = "Run: bmalph init";
+            try {
+                const content = await readFile(join(projectDir, "CLAUDE.md"), "utf-8");
+                if (content.includes("BMAD-METHOD Integration")) {
+                    return { label, passed: true };
+                }
+                return { label, passed: false, detail: "missing BMAD-METHOD Integration section", hint };
+            }
+            catch (err) {
+                if (isEnoent(err)) {
+                    return { label, passed: false, detail: "CLAUDE.md not found", hint };
+                }
+                return { label, passed: false, detail: `error: ${formatError(err)}`, hint };
+            }
+        },
+    };
+    return [...CORE_CHECKS, slashCommandCheck, claudeMdCheck, ...TRAILING_CHECKS];
+})();

package/dist/commands/implement.d.ts

@@ -0,0 +1,6 @@
+interface ImplementOptions {
+    force?: boolean;
+    projectDir: string;
+}
+export declare function implementCommand(options: ImplementOptions): Promise<void>;
+export {};