bmalph 2.3.0 → 2.5.0

package/README.md

@@ -25,7 +25,11 @@ 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
+- `bmalph check-updates` — Check for upstream updates
+- `bmalph status` — Show project status and phase
+- `bmalph reset` — Remove all bmalph files
+- `bmalph watch` — Live Ralph loop dashboard
 
 ## Supported Platforms
 
@@ -155,7 +159,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 +168,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 +185,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 +206,9 @@ 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  |
+| `bmalph reset`         | Remove all bmalph files from the project            |
+| `bmalph watch`         | Live dashboard showing Ralph loop status            |
 
 ### Global options
 
@@ -217,6 +228,31 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 | `-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    |
+| `--dry-run`                | Preview changes without writing files                                              |                |
+
+### implement options
+
+| Flag      | Description                           |
+| --------- | ------------------------------------- |
+| `--force` | Override pre-flight validation errors |
+
+### check-updates options
+
+| Flag     | Description    |
+| -------- | -------------- |
+| `--json` | Output as JSON |
+
+### doctor options
+
+| Flag     | Description    |
+| -------- | -------------- |
+| `--json` | Output as JSON |
+
+### status options
+
+| Flag     | Description    |
+| -------- | -------------- |
+| `--json` | Output as JSON |
 
 ### upgrade options
 
@@ -225,9 +261,22 @@ BMAD (add Epic 2) → /bmalph-implement → Ralph sees changes + picks up Epic 2
 | `--force`   | Skip confirmation prompts |
 | `--dry-run` | Preview changes           |
 
+### reset options
+
+| Flag        | Description              |
+| ----------- | ------------------------ |
+| `--dry-run` | Preview changes          |
+| `--force`   | Skip confirmation prompt |
+
+### watch options
+
+| Flag              | Description                                      |
+| ----------------- | ------------------------------------------------ |
+| `--interval <ms>` | Refresh interval in milliseconds (default: 2000) |
+
 ## Slash Commands
 
-bmalph installs 47 BMAD slash commands. Command delivery varies by platform:
+bmalph installs 51 slash commands (45 BMAD + 6 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 +305,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 +313,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 +343,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 +411,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/
@@ -372,25 +431,33 @@ ls -la .ralph/
 
 ### Reset Installation
 
-If something goes wrong, you can manually reset:
+The simplest way to remove all bmalph files:
 
 ```bash
-# Remove bmalph directories (preserves your project code)
-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
+bmalph reset
 ```
 
+Use `--dry-run` to preview what will be removed, or `--force` to skip confirmation.
+
+#### Manual removal
+
+If the CLI is unavailable, remove these directories and files manually:
+
+```bash
+rm -rf _bmad/ .ralph/ bmalph/
+```
+
+Then remove the bmalph-managed sections from your instructions file. The file depends on your platform:
+
+- **Claude Code** — remove `.claude/commands/` and bmalph section from `CLAUDE.md`
+- **Codex** — remove bmalph sections from `AGENTS.md`
+- **Cursor** — remove `.cursor/rules/bmad.mdc`
+- **Windsurf** — remove `.windsurf/rules/bmad.md`
+- **Copilot** — remove bmalph sections from `.github/copilot-instructions.md`
+- **Aider** — remove bmalph sections from `CONVENTIONS.md`
+
+See the [Supported Platforms](#supported-platforms) table for details. After manual removal, run `bmalph init` to reinitialize.
+
 ## Quick Examples
 
 ### Initialize a new project
@@ -448,10 +515,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 +532,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,9 @@ 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 { watchCommand } from "./commands/watch.js";
 import { setVerbose, setQuiet } from "./utils/logger.js";
 import { getPackageVersion } from "./installer.js";
 import { isEnoent } from "./utils/errors.js";
@@ -79,4 +82,20 @@ 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() }));
+program
+    .command("watch")
+    .description("Live dashboard showing Ralph loop status, circuit breaker, and activity")
+    .option("--interval <ms>", "Refresh interval in milliseconds (default: 2000)")
+    .action(async (opts) => watchCommand({ ...opts, projectDir: await resolveAndValidateProjectDir() }));
 void program.parseAsync();

package/dist/commands/doctor.d.ts

@@ -37,15 +37,4 @@ export declare function runDoctor(options: DoctorOptions): Promise<DoctorResult>
  * 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

@@ -1,6 +1,5 @@
 import chalk from "chalk";
 import { readFile, stat } from "fs/promises";
-import { exists } from "../utils/file-system.js";
 import { join } from "path";
 import { readJsonFile } from "../utils/json.js";
 import { readConfig } from "../utils/config.js";
@@ -64,10 +63,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 +87,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 +413,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 },
@@ -435,51 +450,3 @@ export function buildCheckRegistry(platform) {
     }));
     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 {};

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/init.js

@@ -1,10 +1,12 @@
 import chalk from "chalk";
 import inquirer from "inquirer";
 import { writeConfig } from "../utils/config.js";
-import { installProject, mergeInstructionsFile, isInitialized, hasExistingBmadDir, previewInstall, getBundledVersions, } from "../installer.js";
+import { installProject, mergeInstructionsFile, isInitialized, previewInstall, getBundledVersions, } from "../installer.js";
 import { formatDryRunSummary } from "../utils/dryrun.js";
 import { validateProjectName } from "../utils/validate.js";
 import { withErrorHandling } from "../utils/errors.js";
+import { exists } from "../utils/file-system.js";
+import { join } from "path";
 import { isPlatformId, getPlatform } from "../platform/registry.js";
 import { detectPlatform } from "../platform/detect.js";
 export async function initCommand(options) {
@@ -62,7 +64,7 @@ async function runInit(options) {
         console.log("Use 'bmalph upgrade' to update bundled assets to the latest version.");
         return;
     }
-    if (await hasExistingBmadDir(projectDir)) {
+    if (await exists(join(projectDir, "_bmad"))) {
         console.log(chalk.cyan("Existing BMAD installation detected."));
         console.log("Framework files in _bmad/ will be replaced with the managed version.");
         console.log("Planning artifacts in _bmad-output/ will not be modified.\n");

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}`));
+    }
+}