bmalph 2.3.0 → 2.4.0

package/README.md

@@ -25,7 +25,7 @@ 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
 
@@ -155,7 +155,7 @@ Available in any phase for supporting tasks:
 
 > **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.
 
-Use the `/bmalph-implement` slash command in Claude Code, or run the transition from the BMAD agents in Codex.
+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:
 
@@ -164,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.
@@ -177,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 (`[ ]`)
@@ -198,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
 
@@ -218,6 +223,24 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 | `-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
 
 | Flag        | Description               |
@@ -227,7 +250,7 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 
 ## Slash Commands
 
-bmalph installs 47 BMAD slash commands. Command delivery varies by platform:
+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)
@@ -256,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)
 
@@ -264,15 +287,23 @@ 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)
@@ -286,14 +317,16 @@ project/
 │   ├── drivers/               # Platform driver scripts
 │   │   ├── claude-code.sh     # Claude Code driver (uses `claude`)
 │   │   └── codex.sh           # OpenAI Codex driver (uses `codex exec`)
-│   ├── lib/                   # Circuit breaker, response analyzer
+│   ├── 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, platform)
 │   └── state/                 # Phase tracking data
@@ -352,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/
@@ -448,10 +481,10 @@ 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:**
@@ -465,9 +498,9 @@ bash .ralph/ralph_loop.sh
 # 3. Reference BMAD agents by name (analyst, pm, architect)
 #    Follow phases: Analysis → Planning → Solutioning
 
-# 4. For full tier platforms (Codex), transition via BMAD agents
-#    then start Ralph:
-bash .ralph/ralph_loop.sh
+# 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";
@@ -79,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.js

@@ -64,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;
     }
@@ -88,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");
 }
@@ -399,6 +414,7 @@ async function checkUpstreamGitHubStatus(_projectDir) {
 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 },

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 {};

package/dist/commands/implement.js

@@ -0,0 +1,82 @@
+import chalk from "chalk";
+import { access } from "fs/promises";
+import { join } from "path";
+import { runTransition } from "../transition/orchestration.js";
+import { withErrorHandling } from "../utils/errors.js";
+import { resolveProjectPlatform } from "../platform/resolve.js";
+export async function implementCommand(options) {
+    await withErrorHandling(() => runImplement(options));
+}
+async function runImplement(options) {
+    const { projectDir, force } = options;
+    // Re-run protection: warn if implement was already run
+    try {
+        await access(join(projectDir, ".ralph/@fix_plan.md"));
+        if (!force) {
+            console.log(chalk.yellow("Warning: bmalph implement has already been run."));
+            console.log("Re-running will overwrite PROMPT.md, PROJECT_CONTEXT.md, @AGENT.md, and SPECS_INDEX.md.");
+            console.log("Fix plan progress will be preserved.\n");
+            console.log(`Use ${chalk.bold("--force")} to proceed anyway.`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    catch {
+        // fix_plan doesn't exist — first run, proceed
+    }
+    const platform = await resolveProjectPlatform(projectDir);
+    const result = await runTransition(projectDir, { force });
+    // Print preflight issues with severity icons
+    if (result.preflightIssues && result.preflightIssues.length > 0) {
+        console.log(chalk.bold("\nPre-flight checks\n"));
+        for (const issue of result.preflightIssues) {
+            console.log(`  ${severityIcon(issue)} ${issue.message}`);
+            if (issue.suggestion) {
+                console.log(chalk.dim(`     ${issue.suggestion}`));
+            }
+        }
+        console.log("");
+    }
+    // Print warnings
+    if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+            console.log(chalk.yellow(`  ! ${warning}`));
+        }
+        console.log("");
+    }
+    // Generated files summary
+    if (result.generatedFiles.length > 0) {
+        console.log(chalk.bold("\nGenerated files\n"));
+        for (const file of result.generatedFiles) {
+            const icon = file.action === "created" ? chalk.green("+") : chalk.cyan("~");
+            console.log(`  ${icon} ${file.path}`);
+        }
+        console.log("");
+    }
+    // Summary
+    const preserved = result.fixPlanPreserved ? chalk.dim(" (progress preserved)") : "";
+    console.log(chalk.green(`Transition complete: ${result.storiesCount} stories`) + preserved);
+    if (result.warnings.length > 0) {
+        console.log(chalk.yellow(`  ${result.warnings.length} warning(s)`));
+    }
+    // Driver instructions
+    console.log("");
+    if (platform.tier === "full") {
+        console.log(`Start the Ralph loop:\n`);
+        console.log(`    bash .ralph/drivers/${platform.id}.sh`);
+    }
+    else {
+        console.log(`Ralph requires a full-tier platform (claude-code or codex). ` +
+            `Current platform: ${platform.displayName}`);
+    }
+}
+function severityIcon(issue) {
+    switch (issue.severity) {
+        case "error":
+            return chalk.red("\u2717");
+        case "warning":
+            return chalk.yellow("!");
+        case "info":
+            return chalk.dim("i");
+    }
+}

package/dist/commands/reset.d.ts

@@ -0,0 +1,7 @@
+interface ResetOptions {
+    dryRun?: boolean;
+    force?: boolean;
+    projectDir: string;
+}
+export declare function resetCommand(options: ResetOptions): Promise<void>;
+export {};

package/dist/commands/reset.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { isInitialized } from "../installer.js";
+import { buildResetPlan, executeResetPlan, planToDryRunActions } from "../reset.js";
+import { formatDryRunSummary } from "../utils/dryrun.js";
+import { withErrorHandling } from "../utils/errors.js";
+import { resolveProjectPlatform } from "../platform/resolve.js";
+export async function resetCommand(options) {
+    await withErrorHandling(() => runReset(options));
+}
+async function runReset(options) {
+    const projectDir = options.projectDir;
+    if (!(await isInitialized(projectDir))) {
+        console.log(chalk.red("bmalph is not initialized. Nothing to reset."));
+        return;
+    }
+    const platform = await resolveProjectPlatform(projectDir);
+    const plan = await buildResetPlan(projectDir, platform);
+    // Preview
+    const actions = planToDryRunActions(plan);
+    if (actions.length === 0) {
+        console.log(chalk.dim("Nothing to reset."));
+        return;
+    }
+    // Dry-run mode
+    if (options.dryRun) {
+        console.log(formatDryRunSummary(actions));
+        return;
+    }
+    // Show preview before confirmation
+    for (const action of actions) {
+        if (action.type === "delete") {
+            console.log(`  ${chalk.red("delete")} ${action.path}`);
+        }
+        else if (action.type === "modify") {
+            console.log(`  ${chalk.yellow("modify")} ${action.path}`);
+        }
+        else if (action.type === "warn") {
+            console.log(`  ${chalk.yellow("warn")}   ${action.path}${action.reason ? ` (${action.reason})` : ""}`);
+        }
+    }
+    // Confirm unless --force or non-interactive
+    if (!options.force) {
+        if (!process.stdin.isTTY) {
+            throw new Error("Non-interactive mode requires --force flag for reset");
+        }
+        const { confirm } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: "This will remove all bmalph files from the project. Continue?",
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            console.log("Aborted.");
+            return;
+        }
+    }
+    // Execute
+    console.log("\nResetting...");
+    await executeResetPlan(projectDir, plan);
+    // Summary
+    console.log(chalk.green("\nReset complete."));
+    if (plan.directories.length > 0) {
+        console.log(chalk.dim("\nRemoved:"));
+        for (const dir of plan.directories) {
+            console.log(`  ${dir}/`);
+        }
+    }
+    if (plan.commandFiles.length > 0) {
+        console.log(chalk.dim("\nRemoved commands:"));
+        for (const file of plan.commandFiles) {
+            console.log(`  ${file}`);
+        }
+    }
+    // Show warnings
+    for (const warning of plan.warnings) {
+        console.log(chalk.yellow(`\nNote: ${warning.path} ${warning.message}`));
+    }
+}

package/dist/commands/status.js

@@ -2,6 +2,8 @@ import chalk from "chalk";
 import { readConfig } from "../utils/config.js";
 import { readState, readRalphStatus, getPhaseLabel, getPhaseInfo } from "../utils/state.js";
 import { withErrorHandling } from "../utils/errors.js";
+import { resolveProjectPlatform } from "../platform/resolve.js";
+import { scanProjectArtifacts } from "../transition/artifact-scan.js";
 export async function statusCommand(options) {
     await withErrorHandling(() => runStatus(options));
 }
@@ -15,17 +17,32 @@ export async function runStatus(options) {
     }
     // Read current state
     const state = await readState(projectDir);
-    const phase = state?.currentPhase ?? 1;
+    const storedPhase = state?.currentPhase ?? 1;
     const status = state?.status ?? "planning";
-    const phaseName = getPhaseLabel(phase);
-    const phaseInfo = getPhaseInfo(phase);
     // Read Ralph status if in implementation phase
     let ralphStatus = null;
-    if (phase === 4) {
+    if (storedPhase === 4) {
         ralphStatus = await readRalphStatus(projectDir);
     }
-    // Determine next action
-    const nextAction = getNextAction(phase, status, ralphStatus);
+    // Scan artifacts for phases 1-3 to detect actual progress
+    let artifactScan = null;
+    let phase = storedPhase;
+    let phaseDetected = false;
+    if (phase < 4) {
+        artifactScan = await scanProjectArtifacts(projectDir);
+        if (artifactScan && artifactScan.detectedPhase > phase) {
+            phase = artifactScan.detectedPhase;
+            phaseDetected = true;
+        }
+    }
+    const phaseName = getPhaseLabel(phase);
+    const phaseInfo = getPhaseInfo(phase);
+    // Resolve platform for next action hints
+    const platform = await resolveProjectPlatform(projectDir);
+    // Determine next action — use artifact-based suggestion when available
+    const nextAction = artifactScan && phaseDetected
+        ? artifactScan.nextAction
+        : getNextAction(phase, status, ralphStatus, platform);
     if (options.json) {
         const output = {
             phase,
@@ -40,6 +57,14 @@ export async function runStatus(options) {
                 tasksTotal: ralphStatus.tasksTotal,
             };
         }
+        if (artifactScan) {
+            output.artifacts = {
+                directory: artifactScan.directory,
+                found: artifactScan.found,
+                detectedPhase: artifactScan.detectedPhase,
+                missing: artifactScan.missing,
+            };
+        }
         if (nextAction) {
             output.nextAction = nextAction;
         }
@@ -48,9 +73,18 @@ export async function runStatus(options) {
     }
     // Human-readable output
     console.log(chalk.bold("bmalph status\n"));
-    console.log(`  ${chalk.cyan("Phase:")} ${phase} - ${phaseName}`);
+    const phaseLabel = phaseDetected
+        ? `${phase} - ${phaseName} (detected from artifacts)`
+        : `${phase} - ${phaseName}`;
+    console.log(`  ${chalk.cyan("Phase:")} ${phaseLabel}`);
     console.log(`  ${chalk.cyan("Agent:")} ${phaseInfo.agent}`);
     console.log(`  ${chalk.cyan("Status:")} ${formatStatus(status)}`);
+    // Show artifact checklist for phases 1-3
+    if (artifactScan) {
+        console.log("");
+        console.log(chalk.bold(`  Artifacts (${artifactScan.directory})`));
+        printArtifactChecklist(artifactScan);
+    }
     if (phase === 4 && ralphStatus) {
         console.log("");
         console.log(chalk.bold("  Ralph Loop"));
@@ -68,6 +102,45 @@ export async function runStatus(options) {
         console.log(`  ${chalk.cyan("Next:")} ${nextAction}`);
     }
 }
+const ARTIFACT_DEFINITIONS = [
+    { phase: 1, name: "Product Brief", required: false },
+    { phase: 1, name: "Market Research", required: false },
+    { phase: 1, name: "Domain Research", required: false },
+    { phase: 1, name: "Technical Research", required: false },
+    { phase: 2, name: "PRD", required: true },
+    { phase: 2, name: "UX Design", required: false },
+    { phase: 3, name: "Architecture", required: true },
+    { phase: 3, name: "Epics & Stories", required: true },
+    { phase: 3, name: "Readiness Report", required: true },
+];
+const PHASE_LABELS = {
+    1: "Phase 1 - Analysis",
+    2: "Phase 2 - Planning",
+    3: "Phase 3 - Solutioning",
+};
+function printArtifactChecklist(scan) {
+    const foundByName = new Map();
+    for (const artifacts of [scan.phases[1], scan.phases[2], scan.phases[3]]) {
+        for (const artifact of artifacts) {
+            foundByName.set(artifact.name, artifact);
+        }
+    }
+    let currentPhase = 0;
+    for (const def of ARTIFACT_DEFINITIONS) {
+        if (def.phase !== currentPhase) {
+            currentPhase = def.phase;
+            console.log(`    ${PHASE_LABELS[currentPhase]}`);
+        }
+        const found = foundByName.get(def.name);
+        if (found) {
+            console.log(`      ${chalk.green("*")} ${def.name} (${found.filename})`);
+        }
+        else {
+            const suffix = def.required ? " (required)" : "";
+            console.log(`      ${chalk.dim("-")} ${def.name}${suffix}`);
+        }
+    }
+}
 function formatStatus(status) {
     switch (status) {
         case "planning":
@@ -94,7 +167,7 @@ function formatRalphStatus(status) {
             return status;
     }
 }
-function getNextAction(phase, status, ralphStatus) {
+function getNextAction(phase, status, ralphStatus, platform) {
     if (status === "completed") {
         return null;
     }
@@ -104,10 +177,13 @@ function getNextAction(phase, status, ralphStatus) {
         case 2:
             return "Run /pm to create PRD";
         case 3:
-            return "Run /bmalph-implement when ready for implementation";
+            return "Run: bmalph implement";
         case 4:
             if (!ralphStatus || ralphStatus.status === "not_started") {
-                return "Start Ralph loop with: bash .ralph/ralph_loop.sh";
+                if (platform.tier === "full") {
+                    return `Start Ralph loop with: bash .ralph/drivers/${platform.id}.sh`;
+                }
+                return "Ralph requires a full-tier platform (Claude Code or Codex)";
             }
             if (ralphStatus.status === "blocked") {
                 return "Review Ralph logs: bmalph doctor";

package/dist/platform/claude-code.js

@@ -36,7 +36,6 @@ Use \`/bmalph\` to navigate phases. Use \`/bmad-help\` to discover all commands.
 | \`/bmalph-implement\` | Transition planning artifacts → prepare Ralph loop |
 | \`/bmalph-upgrade\` | Update bundled assets to match current bmalph version |
 | \`/bmalph-doctor\` | Check project health and report issues |
-| \`/bmalph-reset\` | Reset state (soft or hard reset with confirmation) |
 
 ### Available Agents
 

package/dist/reset.d.ts

@@ -0,0 +1,18 @@
+import type { Platform } from "./platform/types.js";
+import type { DryRunAction } from "./utils/dryrun.js";
+export interface ResetPlan {
+    directories: string[];
+    commandFiles: string[];
+    instructionsCleanup: {
+        path: string;
+        sectionsToRemove: string[];
+    } | null;
+    gitignoreLines: string[];
+    warnings: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+export declare function buildResetPlan(projectDir: string, platform: Platform): Promise<ResetPlan>;
+export declare function executeResetPlan(projectDir: string, plan: ResetPlan): Promise<void>;
+export declare function planToDryRunActions(plan: ResetPlan): DryRunAction[];