bmalph 2.9.0 → 2.11.0

package/README.md

@@ -279,12 +279,12 @@ BMAD (add Epic 2) → bmalph implement → Ralph sees changes + picks up Epic 2
 
 ### run options
 
-| Flag                   | Description                                                                 |
-| ---------------------- | --------------------------------------------------------------------------- |
-| `--driver <platform>`  | Override platform driver (claude-code, codex, opencode, copilot, cursor)    |
-| `--review/--no-review` | Enable/disable periodic code review (Claude Code only, prompted by default) |
-| `--interval <ms>`      | Dashboard refresh interval in milliseconds (default: 2000)                  |
-| `--no-dashboard`       | Run Ralph without the dashboard overlay                                     |
+| Flag                  | Description                                                                              |
+| --------------------- | ---------------------------------------------------------------------------------------- |
+| `--driver <platform>` | Override platform driver (claude-code, codex, opencode, copilot, cursor)                 |
+| `--review [mode]`     | Quality review: `enhanced` (every 5 loops) or `ultimate` (every story). Claude Code only |
+| `--interval <ms>`     | Dashboard refresh interval in milliseconds (default: 2000)                               |
+| `--no-dashboard`      | Run Ralph without the dashboard overlay                                                  |
 
 ### watch options
 
@@ -416,7 +416,7 @@ Safety mechanisms:
 
 - **Circuit breaker** — prevents infinite loops on failing stories
 - **Response analyzer** — detects stuck or repeating outputs
-- **Code review** — optional periodic review every 5 loops (`--review`, Claude Code only). A read-only session analyzes git diffs and feeds structured findings into the next implementation loop
+- **Code review** — optional quality review (`--review [mode]`, Claude Code only). Enhanced: periodic review every 5 loops. Ultimate: review after every completed story. A read-only session analyzes git diffs and feeds structured findings into the next implementation loop
 - **Completion** — loop exits when all `@fix_plan.md` items are checked off
 
 Cursor-specific runtime checks:

package/dist/cli.js

@@ -105,7 +105,8 @@ program
     .option("--driver <platform>", "Override platform driver (claude-code, codex, opencode, copilot, cursor)")
     .option("--interval <ms>", "Dashboard refresh interval in milliseconds (default: 2000)")
     .option("--no-dashboard", "Run Ralph without the dashboard overlay")
-    .option("--review", "Enable periodic code review loop (~10-14% more tokens)")
+    .option("--review [mode]", "Quality review: enhanced (~10-14% tokens) or ultimate (~20-30%)")
+    .option("--no-review", "Disable code review")
     .action(async (opts) => runCommand({ ...opts, projectDir: await resolveAndValidateProjectDir() }));
 void program.parseAsync();
 //# sourceMappingURL=cli.js.map

package/dist/commands/doctor-checks.js

@@ -68,6 +68,34 @@ export async function checkJq(projectDir) {
                     : "Install jq: sudo apt-get install jq",
     };
 }
+export async function checkGitRepo(projectDir) {
+    const label = "git repository with commits";
+    const gitDir = await runBashCommand("git rev-parse --git-dir", { cwd: projectDir });
+    if (gitDir.exitCode !== 0) {
+        return {
+            label,
+            passed: false,
+            detail: "not a git repository",
+            hint: "Run: git init && git add -A && git commit -m 'initial commit'",
+        };
+    }
+    const head = await runBashCommand("git rev-parse HEAD", { cwd: projectDir });
+    if (head.exitCode !== 0) {
+        return {
+            label,
+            passed: false,
+            detail: "no commits found",
+            hint: "Run: git add -A && git commit -m 'initial commit'",
+        };
+    }
+    const branch = await runBashCommand("git branch --show-current", { cwd: projectDir });
+    const branchName = branch.stdout.trim();
+    return {
+        label,
+        passed: true,
+        detail: branchName ? `branch: ${branchName}` : undefined,
+    };
+}
 export async function checkBmadDir(projectDir) {
     return checkDir(join(projectDir, "_bmad"), "_bmad/ directory present", "Run: bmalph init");
 }

package/dist/commands/doctor.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { withErrorHandling } from "../utils/errors.js";
 import { resolveProjectPlatform } from "../platform/resolve.js";
-import { checkNodeVersion, checkBash, checkJq, checkConfig, checkBmadDir, checkRalphLoop, checkRalphLib, } from "./doctor-checks.js";
+import { checkNodeVersion, checkBash, checkGitRepo, checkJq, checkConfig, checkBmadDir, checkRalphLoop, checkRalphLib, } from "./doctor-checks.js";
 import { checkGitignore, checkVersionMarker, checkUpstreamVersions, } from "./doctor-health-checks.js";
 import { checkCircuitBreaker, checkRalphSession, checkApiCalls, checkUpstreamGitHubStatus, } from "./doctor-runtime-checks.js";
 export async function doctorCommand(options) {
@@ -62,6 +62,7 @@ export async function runDoctor(options, checksOverride) {
 const CORE_CHECKS = [
     { id: "node-version", run: checkNodeVersion },
     { id: "bash-available", run: checkBash },
+    { id: "git-repo", run: checkGitRepo },
     { id: "jq-available", run: checkJq },
     { id: "config-valid", run: checkConfig },
     { id: "bmad-dir", run: checkBmadDir },

package/dist/commands/run.js

@@ -3,7 +3,7 @@ import { readConfig } from "../utils/config.js";
 import { withErrorHandling } from "../utils/errors.js";
 import { isPlatformId, getPlatform, getFullTierPlatformNames } from "../platform/registry.js";
 import { validateCursorRuntime } from "../platform/cursor-runtime-checks.js";
-import { validateBashAvailable, validateRalphLoop, spawnRalphLoop } from "../run/ralph-process.js";
+import { validateBashAvailable, validateRalphLoop, validateGitRepo, spawnRalphLoop, } from "../run/ralph-process.js";
 import { startRunDashboard } from "../run/run-dashboard.js";
 import { parseInterval } from "../utils/validate.js";
 import { getDashboardTerminalSupport } from "../watch/frame-writer.js";
@@ -24,10 +24,13 @@ async function executeRun(options) {
     if (platform.experimental) {
         console.log(chalk.yellow(`Warning: ${platform.displayName} support is experimental`));
     }
-    const reviewEnabled = await resolveReviewMode(options.review, platform);
-    if (reviewEnabled) {
+    const reviewMode = await resolveReviewMode(options.review, platform);
+    if (reviewMode === "enhanced") {
         console.log(chalk.cyan("Enhanced mode: code review every 5 implementation loops"));
     }
+    else if (reviewMode === "ultimate") {
+        console.log(chalk.cyan("Ultimate mode: code review after every completed story"));
+    }
     const interval = parseInterval(options.interval);
     let useDashboard = dashboard;
     if (useDashboard) {
@@ -37,16 +40,20 @@ async function executeRun(options) {
             useDashboard = false;
         }
     }
-    await Promise.all([validateBashAvailable(), validateRalphLoop(projectDir)]);
+    await Promise.all([
+        validateBashAvailable(),
+        validateRalphLoop(projectDir),
+        validateGitRepo(projectDir),
+    ]);
     if (platform.id === "cursor") {
         await validateCursorRuntime(projectDir);
     }
     const ralph = spawnRalphLoop(projectDir, platform.id, {
         inheritStdio: !useDashboard,
-        ...(reviewEnabled && { reviewEnabled }),
+        reviewMode,
     });
     if (useDashboard) {
-        await startRunDashboard({ projectDir, interval, ralph, reviewEnabled });
+        await startRunDashboard({ projectDir, interval, ralph, reviewMode });
         if (ralph.state === "stopped") {
             applyRalphExitCode(ralph.exitCode);
         }
@@ -70,34 +77,44 @@ function resolvePlatform(driverOverride, configPlatform) {
     }
     return getPlatform(id);
 }
+const VALID_REVIEW_MODES = new Set(["enhanced", "ultimate"]);
 async function resolveReviewMode(reviewFlag, platform) {
-    if (reviewFlag === true) {
+    if (reviewFlag === false) {
+        return "off";
+    }
+    if (reviewFlag === true || typeof reviewFlag === "string") {
         if (platform.id !== "claude-code") {
             throw new Error("--review requires Claude Code (other drivers lack read-only enforcement)");
         }
-        return true;
-    }
-    if (reviewFlag === false) {
-        return false;
+        if (reviewFlag === true) {
+            return "enhanced";
+        }
+        if (!VALID_REVIEW_MODES.has(reviewFlag)) {
+            throw new Error(`Unknown review mode: ${reviewFlag}. Valid modes: enhanced, ultimate`);
+        }
+        return reviewFlag;
     }
     if (platform.id !== "claude-code") {
-        return false;
+        return "off";
     }
     if (!process.stdin.isTTY) {
-        return false;
+        return "off";
     }
     const { default: select } = await import("@inquirer/select");
-    const mode = await select({
+    return select({
         message: "Quality mode:",
         choices: [
-            { name: "Standard — current behavior (no extra cost)", value: "standard" },
+            { name: "Standard — no code review (no extra cost)", value: "off" },
             {
                 name: "Enhanced — periodic code review every 5 loops (~10-14% more tokens)",
                 value: "enhanced",
             },
+            {
+                name: "Ultimate — review after every completed story (~20-30% more tokens)",
+                value: "ultimate",
+            },
         ],
-        default: "standard",
+        default: "off",
     });
-    return mode === "enhanced";
 }
 //# sourceMappingURL=run.js.map

package/dist/installer/template-files.js

@@ -55,6 +55,25 @@ const REVIEW_TEMPLATE_BLOCK = `# ===============================================
 # PERIODIC CODE REVIEW
 # =============================================================================
 
+# Review mode: off, enhanced, or ultimate (set via 'bmalph run --review [mode]')
+# - off:      no code review (default)
+# - enhanced: periodic review every REVIEW_INTERVAL loops (~10-14% more tokens)
+# - ultimate: review after every completed story (~20-30% more tokens)
+# The review agent analyzes git diffs and outputs findings for the next implementation loop.
+# Currently supported on Claude Code only.
+REVIEW_MODE="\${REVIEW_MODE:-off}"
+
+# (Legacy) Enables review — prefer REVIEW_MODE instead
+REVIEW_ENABLED="\${REVIEW_ENABLED:-false}"
+
+# Number of implementation loops between review sessions (enhanced mode only)
+REVIEW_INTERVAL="\${REVIEW_INTERVAL:-5}"
+
+`;
+const PREVIOUS_REVIEW_TEMPLATE_BLOCK = `# =============================================================================
+# PERIODIC CODE REVIEW
+# =============================================================================
+
 # Enable periodic code review loops (set via 'bmalph run --review' or manually)
 # When enabled, Ralph runs a read-only review session every REVIEW_INTERVAL loops.
 # The review agent analyzes git diffs and outputs findings for the next implementation loop.
@@ -229,11 +248,21 @@ async function isRalphrcCustomized(filePath, platformId) {
     if (matchesManagedPermissionVariants(content, templateWithoutReview)) {
         return false;
     }
+    // Check variants with previous review block (pre-ultimate installs)
+    const templateWithPreviousReview = currentTemplate.replace(REVIEW_TEMPLATE_BLOCK, PREVIOUS_REVIEW_TEMPLATE_BLOCK);
+    if (matchesManagedPermissionVariants(content, templateWithPreviousReview)) {
+        return false;
+    }
     // Check variants without both quality gates and review blocks
     const templateWithoutQGAndReview = templateWithoutQG.replace(REVIEW_TEMPLATE_BLOCK, "");
     if (matchesManagedPermissionVariants(content, templateWithoutQGAndReview)) {
         return false;
     }
+    // Check variants without quality gates but with previous review block
+    const templateWithoutQGButPreviousReview = templateWithoutQG.replace(REVIEW_TEMPLATE_BLOCK, PREVIOUS_REVIEW_TEMPLATE_BLOCK);
+    if (matchesManagedPermissionVariants(content, templateWithoutQGButPreviousReview)) {
+        return false;
+    }
     const legacyTemplate = normalizeManagedRalphrcContent(renderLegacyRalphrcTemplate(platformId));
     return content !== legacyTemplate;
 }

package/dist/run/ralph-process.js

@@ -123,11 +123,28 @@ export async function validateRalphLoop(projectDir) {
         throw new Error(`${RALPH_LOOP_PATH} not found. Run: bmalph init`);
     }
 }
+export async function validateGitRepo(projectDir) {
+    const gitDir = await runBashCommand("git rev-parse --git-dir", { cwd: projectDir });
+    if (gitDir.exitCode !== 0) {
+        throw new Error("No git repository found. Ralph requires git for progress detection.\n" +
+            "Run: git init && git add -A && git commit -m 'initial commit'");
+    }
+    const head = await runBashCommand("git rev-parse HEAD", { cwd: projectDir });
+    if (head.exitCode !== 0) {
+        throw new Error("Git repository has no commits. Ralph requires at least one commit for progress detection.\n" +
+            "Run: git add -A && git commit -m 'initial commit'");
+    }
+}
 export function spawnRalphLoop(projectDir, platformId, options) {
     const env = { ...process.env, PLATFORM_DRIVER: platformId };
-    if (options.reviewEnabled) {
-        env.REVIEW_ENABLED = "true";
-        env.REVIEW_INTERVAL = "5";
+    if (options.reviewMode) {
+        env.REVIEW_MODE = options.reviewMode;
+        if (options.reviewMode !== "off") {
+            env.REVIEW_ENABLED = "true";
+            if (options.reviewMode === "enhanced") {
+                env.REVIEW_INTERVAL = "5";
+            }
+        }
     }
     const child = spawn(cachedBashCommand ?? "bash", [BASH_RALPH_LOOP_PATH], {
         cwd: projectDir,

package/dist/run/run-dashboard.js

@@ -1,15 +1,16 @@
+import { formatExitReason } from "../utils/format-status.js";
 import { createRefreshCallback } from "../watch/dashboard.js";
 import { createTerminalFrameWriter } from "../watch/frame-writer.js";
 import { FileWatcher } from "../watch/file-watcher.js";
 import { renderFooterLine } from "../watch/renderer.js";
-export function renderStatusBar(ralph, reviewEnabled) {
+export function renderStatusBar(ralph, reviewMode) {
     const pid = ralph.child.pid ?? "?";
-    const badge = reviewEnabled ? " [review]" : "";
+    const badge = reviewMode === "ultimate" ? " [ultimate]" : reviewMode === "enhanced" ? " [review]" : "";
     switch (ralph.state) {
         case "running":
             return `Ralph: running (PID ${pid})${badge} | q: stop/detach`;
         case "stopped":
-            return `Ralph: stopped (exit ${ralph.exitCode ?? "?"}) | q: quit`;
+            return `Ralph: stopped — ${formatExitReason(ralph.exitCode)} | q: quit`;
         case "detached":
             return `Ralph: detached (PID ${pid})`;
     }
@@ -18,12 +19,12 @@ export function renderQuitPrompt() {
     return "Stop (s) | Detach (d) | Cancel (c)";
 }
 export async function startRunDashboard(options) {
-    const { projectDir, interval, ralph, reviewEnabled } = options;
+    const { projectDir, interval, ralph, reviewMode } = options;
     const frameWriter = createTerminalFrameWriter();
     let showingPrompt = false;
     let stopped = false;
     const footerRenderer = (lastUpdated, cols) => {
-        const leftText = showingPrompt ? renderQuitPrompt() : renderStatusBar(ralph, reviewEnabled);
+        const leftText = showingPrompt ? renderQuitPrompt() : renderStatusBar(ralph, reviewMode);
         return renderFooterLine(leftText, `Updated: ${lastUpdated.toISOString().slice(11, 19)}`, cols);
     };
     const refresh = createRefreshCallback(projectDir, (frame) => {

package/dist/transition/context-output.js

@@ -22,13 +22,11 @@ export async function generateContextOutputs(projectDir, inputs) {
     info("Generating PROJECT_CONTEXT.md...");
     const projectContextPath = join(projectDir, ".ralph/PROJECT_CONTEXT.md");
     const projectContextExisted = await exists(projectContextPath);
-    let projectContext = null;
     let truncationWarnings = [];
     if (inputs.artifactContents.size > 0) {
         const { context, truncated } = extractProjectContext(inputs.artifactContents);
-        projectContext = context;
         truncationWarnings = detectTruncation(truncated);
-        const contextMd = generateProjectContextMd(projectContext, projectName);
+        const contextMd = generateProjectContextMd(context, projectName);
         await atomicWriteFile(projectContextPath, contextMd);
         generatedFiles.push({
             path: ".ralph/PROJECT_CONTEXT.md",
@@ -46,7 +44,7 @@ export async function generateContextOutputs(projectDir, inputs) {
             prompt = existingPrompt.replace(/\[YOUR PROJECT NAME\]/g, projectName);
         }
         else {
-            prompt = generatePrompt(projectName, projectContext ?? undefined);
+            prompt = generatePrompt(projectName);
         }
     }
     catch (err) {
@@ -56,7 +54,7 @@ export async function generateContextOutputs(projectDir, inputs) {
         else {
             warn(`Could not read existing PROMPT.md: ${formatError(err)}`);
         }
-        prompt = generatePrompt(projectName, projectContext ?? undefined);
+        prompt = generatePrompt(projectName);
     }
     await atomicWriteFile(join(projectDir, ".ralph/PROMPT.md"), prompt);
     generatedFiles.push({ path: ".ralph/PROMPT.md", action: promptExisted ? "updated" : "created" });

package/dist/transition/context.js

@@ -186,39 +186,22 @@ export function generateProjectContextMd(context, projectName) {
     }
     return lines.join("\n");
 }
-export function generatePrompt(projectName, context) {
-    // Build context sections if provided
-    const contextSections = context
-        ? [
-            context.projectGoals && `### Project Goals\n${context.projectGoals}`,
-            context.successMetrics && `### Success Metrics\n${context.successMetrics}`,
-            context.architectureConstraints &&
-                `### Architecture Constraints\n${context.architectureConstraints}`,
-            context.scopeBoundaries && `### Scope\n${context.scopeBoundaries}`,
-            context.technicalRisks && `### Technical Risks\n${context.technicalRisks}`,
-            context.targetUsers && `### Target Users\n${context.targetUsers}`,
-            context.nonFunctionalRequirements &&
-                `### Non-Functional Requirements\n${context.nonFunctionalRequirements}`,
-            context.designGuidelines && `### Design Guidelines\n${context.designGuidelines}`,
-            context.researchInsights && `### Research Insights\n${context.researchInsights}`,
-        ]
-            .filter(Boolean)
-            .join("\n\n")
-        : "";
-    const projectContextBlock = contextSections
-        ? `
-
-## Project Specifications (CRITICAL - READ THIS)
-
-${contextSections}
-`
-        : "";
+export function generatePrompt(projectName) {
     return `# Ralph Development Instructions
 
 ## Context
 You are an autonomous AI development agent working on the ${projectName} project.
 You follow BMAD-METHOD's developer (Amelia) persona and TDD methodology.
-${projectContextBlock}
+
+## Current Objectives
+1. Read .ralph/@fix_plan.md and identify the next incomplete story
+2. Check existing codebase for related code — especially which existing files need changes to integrate your work
+3. Implement the story using TDD (red-green-refactor)
+4. Run tests after implementation
+5. Toggle the completed story checkbox in @fix_plan.md from \`- [ ]\` to \`- [x]\`
+6. Commit with descriptive conventional commit message
+7. Read specs ONLY if the story's inline acceptance criteria are insufficient
+
 ## Development Methodology (BMAD Dev Agent)
 
 For each story in @fix_plan.md:
@@ -226,30 +209,27 @@ For each story in @fix_plan.md:
 2. Write failing tests first (RED)
 3. Implement minimum code to pass tests (GREEN)
 4. Refactor while keeping tests green (REFACTOR)
-5. Toggle the completed story checkbox in @fix_plan.md from \`- [ ]\` to \`- [x]\`
+5. Toggle the completed story checkbox
 6. Commit with descriptive conventional commit message
 
-## Specs Reading Strategy
-1. Read .ralph/SPECS_INDEX.md first for a prioritized overview of all spec files
-2. Follow the reading order in SPECS_INDEX.md:
-   - **Critical**: Always read fully (PRD, architecture, stories)
-   - **High**: Read for implementation details (test design, readiness)
-   - **Medium**: Reference as needed (UX specs, sprint plans)
-   - **Low**: Optional background (brainstorming sessions)
-3. For files marked [LARGE], scan headers first and read relevant sections
+## Specs Reference (Read On Demand)
+- .ralph/SPECS_INDEX.md lists all spec files with paths and priorities
+- .ralph/PROJECT_CONTEXT.md summarizes project goals, constraints, and scope
+- Read specific specs only when the current story requires clarification
+- For files marked [LARGE] in SPECS_INDEX.md, scan headers first
 
-## Current Objectives
-1. Read .ralph/PROJECT_CONTEXT.md for project goals, constraints, and scope
-2. Read .ralph/SPECS_INDEX.md for prioritized spec file overview
-3. Study .ralph/specs/ following the reading order in SPECS_INDEX.md
-4. Use the exact spec paths listed in SPECS_INDEX.md instead of assuming a fixed subdirectory layout
-5. Prioritize planning specs first (PRD, architecture, epics/stories, test design, UX)
-6. Review implementation artifacts next (sprint plans, detailed stories) when they exist
-7. Check docs/ for project knowledge and research documents (if present)
-8. Review .ralph/@fix_plan.md for current priorities
-9. Implement the highest priority story using TDD
-10. Run tests after each implementation
-11. Update the completed story checkbox in @fix_plan.md before committing
+## Key Principles
+- Write code within the first few minutes of each loop
+- ONE story per loop - focus completely on it
+- TDD: tests first, always
+- Search the codebase before assuming something isn't implemented
+- Creating new files is often only half the task — wire them into the existing application
+- Commit working changes with descriptive messages
+
+## Session Continuity
+- If you have context from a previous loop, do NOT re-read spec files
+- Resume implementation where you left off
+- Only consult specs when you encounter ambiguity in the current story
 
 ## Progress Tracking (CRITICAL)
 - Ralph tracks progress by counting story checkboxes in @fix_plan.md
@@ -259,12 +239,12 @@ For each story in @fix_plan.md:
 - Set \`TASKS_COMPLETED_THIS_LOOP\` to the exact number of story checkboxes toggled this loop
 - Only valid values: 0 or 1
 
-## Key Principles
-- ONE story per loop - focus completely on it
-- TDD: tests first, always
-- Search the codebase before assuming something isn't implemented
-- Write comprehensive tests with clear documentation
-- Commit working changes with descriptive messages
+## Execution Guidelines
+- Before making changes: search codebase using subagents
+- After implementation: run essential tests for the modified code
+- If tests fail: fix them as part of your current work
+- Keep .ralph/@AGENT.md updated with build/run instructions
+- No placeholder implementations - build it properly
 
 ## Testing Guidelines
 - Write tests BEFORE implementation (TDD)
@@ -272,6 +252,25 @@ For each story in @fix_plan.md:
 - Run the full test suite after implementation
 - Fix any regressions immediately
 
+## Autonomous Mode (CRITICAL)
+- do not ask the user questions during loop execution
+- do not use AskUserQuestion, EnterPlanMode, or ExitPlanMode during loop execution
+- make the safest reasonable assumption and continue
+- prefer small, reversible changes when requirements are ambiguous
+- surface blockers in the Ralph status block instead of starting a conversation
+
+## Self-Review Checklist (Before Reporting Status)
+
+Before writing your RALPH_STATUS block, review your own work:
+
+1. Re-read the diff of files you modified this loop — check for obvious bugs, typos, missing error handling
+2. Verify you did not introduce regressions in existing functionality
+3. Confirm your changes match the spec in .ralph/specs/ for the story you worked on
+4. Check that new functions have proper error handling and edge case coverage
+5. Ensure you did not leave TODO/FIXME/HACK comments without justification
+
+If you find issues, fix them before reporting status.
+
 ## Status Reporting (CRITICAL)
 
 At the end of your response, ALWAYS include this status block:

package/dist/transition/fix-plan-sync.js

@@ -3,7 +3,7 @@ import { join, relative } from "node:path";
 import { debug, info, warn } from "../utils/logger.js";
 import { isEnoent, formatError } from "../utils/errors.js";
 import { atomicWriteFile, exists } from "../utils/file-system.js";
-import { generateFixPlan, parseFixPlan, mergeFixPlanProgress, detectOrphanedCompletedStories, detectRenumberedStories, buildCompletedTitleMap, normalizeTitle, } from "./fix-plan.js";
+import { generateFixPlan, parseFixPlan, mergeFixPlanProgress, collapseCompletedStories, detectOrphanedCompletedStories, detectRenumberedStories, buildCompletedTitleMap, normalizeTitle, } from "./fix-plan.js";
 import { parseSprintStatus } from "./sprint-status.js";
 export async function syncFixPlan(projectDir, inputs) {
     let completedIds = new Set();
@@ -73,7 +73,8 @@ export async function syncFixPlan(projectDir, inputs) {
     info(`Generating fix plan for ${inputs.stories.length} stories...`);
     const newFixPlan = generateFixPlan(inputs.stories, undefined, inputs.planningSpecsSubpath);
     const mergedFixPlan = mergeFixPlanProgress(newFixPlan, completedIds, useTitleBasedMerge ? newTitleMap : undefined, useTitleBasedMerge ? completedTitles : undefined);
-    await atomicWriteFile(fixPlanPath, mergedFixPlan);
+    const compactedFixPlan = collapseCompletedStories(mergedFixPlan);
+    await atomicWriteFile(fixPlanPath, compactedFixPlan);
     return {
         warnings: [...completionWarnings, ...orphanWarnings, ...renumberWarnings],
         fixPlanPreserved,

package/dist/transition/fix-plan.js

@@ -108,6 +108,26 @@ export function buildCompletedTitleMap(items) {
     }
     return map;
 }
+const COMPLETED_STORY_LINE = /^\s*-\s*\[[xX]\]\s*Story\s+[\d.]+:/;
+const INDENTED_DETAIL_LINE = /^\s+>/;
+export function collapseCompletedStories(fixPlan) {
+    const lines = fixPlan.split("\n");
+    const result = [];
+    let skippingDetails = false;
+    for (const line of lines) {
+        if (COMPLETED_STORY_LINE.test(line)) {
+            skippingDetails = true;
+            result.push(line);
+            continue;
+        }
+        if (skippingDetails && INDENTED_DETAIL_LINE.test(line)) {
+            continue;
+        }
+        skippingDetails = false;
+        result.push(line);
+    }
+    return result.join("\n");
+}
 export function mergeFixPlanProgress(newFixPlan, completedIds, titleMap, completedTitles) {
     // Replace [ ] with [x] for completed story IDs or title matches
     return newFixPlan.replace(createOpenFixPlanStoryLinePattern(), (match, prefix, suffix, id) => {

package/dist/transition/section-patterns.js

@@ -1,5 +1,5 @@
 function headingPattern(expression) {
-    return new RegExp(`^##\\s+${expression}(?:\\s*:)?\\s*$`, "im");
+    return new RegExp(`^##\\s+(?:\\d+(?:\\.\\d+)*\\.?\\s+)?${expression}(?:\\s*:)?\\s*$`, "im");
 }
 export const PROJECT_GOALS_SECTION_PATTERNS = [
     headingPattern("Executive Summary"),

package/dist/transition/specs-index.js

@@ -147,8 +147,8 @@ export function formatSpecsIndexMd(index) {
         "",
     ];
     const priorityConfig = [
-        { key: "critical", heading: "Critical (Always Read First)" },
-        { key: "high", heading: "High Priority (Read for Implementation)" },
+        { key: "critical", heading: "Critical (Read When Needed for Current Story)" },
+        { key: "high", heading: "High Priority (Reference as Needed)" },
         { key: "medium", heading: "Medium Priority (Reference as Needed)" },
         { key: "low", heading: "Low Priority (Optional)" },
     ];

package/dist/utils/format-status.js

@@ -1,4 +1,17 @@
 import chalk from "chalk";
+const EXIT_CODE_LABELS = new Map([
+    [0, "completed"],
+    [1, "error"],
+    [124, "timed out"],
+    [130, "interrupted (SIGINT)"],
+    [137, "killed (OOM or SIGKILL)"],
+    [143, "terminated (SIGTERM)"],
+]);
+export function formatExitReason(code) {
+    if (code === null)
+        return "unknown";
+    return EXIT_CODE_LABELS.get(code) ?? `error (exit ${code})`;
+}
 /**
  * Shared status formatting with chalk colors.
  *

package/dist/watch/renderer.js

@@ -296,7 +296,8 @@ export function renderAnalysisPanel(analysis, cols) {
     const lines = [
         [
             `Files: ${String(analysis.filesModified)}`,
-            `Confidence: ${String(analysis.confidenceScore)}%`,
+            `Parse: ${String(analysis.formatConfidence)}%`,
+            `Completion: ${String(analysis.confidenceScore)}%`,
         ].join("    "),
         [`Test-only: ${yesNo(analysis.isTestOnly)}`, `Stuck: ${yesNo(analysis.isStuck)}`].join("    "),
         [

package/dist/watch/state-reader.js

@@ -95,6 +95,7 @@ export async function readAnalysisInfo(projectDir) {
             return null;
         const a = analysis;
         const filesModified = typeof a.files_modified === "number" ? a.files_modified : 0;
+        const formatConfidence = typeof a.format_confidence === "number" ? a.format_confidence : 0;
         const confidenceScore = typeof a.confidence_score === "number" ? a.confidence_score : 0;
         const isTestOnly = typeof a.is_test_only === "boolean" ? a.is_test_only : false;
         const isStuck = typeof a.is_stuck === "boolean" ? a.is_stuck : false;
@@ -108,6 +109,7 @@ export async function readAnalysisInfo(projectDir) {
         const permissionDenialCount = typeof a.permission_denial_count === "number" ? a.permission_denial_count : 0;
         return {
             filesModified,
+            formatConfidence,
             confidenceScore,
             isTestOnly,
             isStuck,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmalph",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "Unified AI Development Framework - BMAD phases with Ralph execution loop",
   "type": "module",
   "bin": {