bmalph 2.7.7 → 2.9.0

package/dist/platform/registry.js

@@ -1,5 +1,6 @@
 import { claudeCodePlatform } from "./claude-code.js";
 import { codexPlatform } from "./codex.js";
+import { opencodePlatform } from "./opencode.js";
 import { cursorPlatform } from "./cursor.js";
 import { windsurfPlatform } from "./windsurf.js";
 import { copilotPlatform } from "./copilot.js";
@@ -7,6 +8,7 @@ import { aiderPlatform } from "./aider.js";
 const PLATFORMS = new Map([
     ["claude-code", claudeCodePlatform],
     ["codex", codexPlatform],
+    ["opencode", opencodePlatform],
     ["cursor", cursorPlatform],
     ["windsurf", windsurfPlatform],
     ["copilot", copilotPlatform],

package/dist/platform/types.js

@@ -8,6 +8,7 @@
 export const PLATFORM_IDS = [
     "claude-code",
     "codex",
+    "opencode",
     "cursor",
     "windsurf",
     "copilot",

package/dist/reset.js

@@ -3,7 +3,7 @@ import { join, posix } from "node:path";
 import { getSlashCommandsDir } from "./installer.js";
 import { exists, atomicWriteFile, parseGitignoreLines, replaceSection, } from "./utils/file-system.js";
 import { isEnoent } from "./utils/errors.js";
-import { BMAD_DIR, RALPH_DIR, BMALPH_DIR, BMAD_OUTPUT_DIR, SKILLS_DIR, SKILLS_PREFIX, } from "./utils/constants.js";
+import { BMAD_DIR, RALPH_DIR, BMALPH_DIR, BMAD_OUTPUT_DIR, GITIGNORE_ENTRIES, SKILLS_PREFIX, } from "./utils/constants.js";
 export async function buildResetPlan(projectDir, platform) {
     const plan = {
         directories: [],
@@ -40,10 +40,10 @@ export async function buildResetPlan(projectDir, platform) {
     // Check for skills to remove (skills delivery only)
     if (platform.commandDelivery.kind === "skills") {
         try {
-            const existingDirs = await readdir(join(projectDir, SKILLS_DIR));
+            const existingDirs = await readdir(join(projectDir, platform.commandDelivery.dir));
             for (const dir of existingDirs) {
                 if (dir.startsWith(SKILLS_PREFIX)) {
-                    plan.commandFiles.push(posix.join(SKILLS_DIR, dir));
+                    plan.commandFiles.push(posix.join(platform.commandDelivery.dir, dir));
                 }
             }
         }
@@ -74,8 +74,7 @@ export async function buildResetPlan(projectDir, platform) {
     try {
         const content = await readFile(join(projectDir, ".gitignore"), "utf-8");
         const existingLines = parseGitignoreLines(content);
-        const bmalpEntries = [".ralph/logs/", "_bmad-output/"];
-        for (const entry of bmalpEntries) {
+        for (const entry of GITIGNORE_ENTRIES) {
             if (existingLines.has(entry)) {
                 plan.gitignoreLines.push(entry);
             }

package/dist/run/ralph-process.js

@@ -5,7 +5,7 @@ import { exists } from "../utils/file-system.js";
 const RALPH_LOOP_PATH = `${RALPH_DIR}/ralph_loop.sh`;
 const BASH_RALPH_LOOP_PATH = `./${RALPH_LOOP_PATH}`;
 const BASH_VALIDATION_TIMEOUT_MS = 3000;
-const BASH_COMMAND_TIMEOUT_MS = 5000;
+const BASH_COMMAND_TIMEOUT_MS = 15000;
 const DEFAULT_WINDOWS_GIT_BASH_PATHS = [
     "C:\\Program Files\\Git\\bin\\bash.exe",
     "C:\\Program Files\\Git\\usr\\bin\\bash.exe",
@@ -13,18 +13,33 @@ const DEFAULT_WINDOWS_GIT_BASH_PATHS = [
     "C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe",
 ];
 let cachedBashCommand;
+let pendingBashCommand;
+let cachedBashVersion;
+let versionDetected = false;
+let pendingBashVersion;
 export async function resolveBashCommand() {
     if (cachedBashCommand) {
         return cachedBashCommand;
     }
-    const candidates = process.platform === "win32" ? getWindowsBashCandidates() : ["bash"];
-    for (const candidate of candidates) {
-        if (await canExecuteBash(candidate)) {
-            cachedBashCommand = candidate;
-            return candidate;
+    if (pendingBashCommand) {
+        return pendingBashCommand;
+    }
+    pendingBashCommand = (async () => {
+        const candidates = process.platform === "win32" ? getWindowsBashCandidates() : ["bash"];
+        for (const candidate of candidates) {
+            if (await canExecuteBash(candidate)) {
+                cachedBashCommand = candidate;
+                return candidate;
+            }
         }
+        throw new Error(getMissingBashMessage());
+    })();
+    try {
+        return await pendingBashCommand;
+    }
+    finally {
+        pendingBashCommand = undefined;
     }
-    throw new Error(getMissingBashMessage());
 }
 export async function validateBashAvailable() {
     await resolveBashCommand();
@@ -59,10 +74,10 @@ export async function runBashCommand(command, options = {}) {
             }
             finish(() => reject(new Error(`bash command timed out: ${command}`)));
         }, timeoutMs);
-        child.stdout?.on("data", (chunk) => {
+        child.stdout.on("data", (chunk) => {
             stdout += chunk.toString();
         });
-        child.stderr?.on("data", (chunk) => {
+        child.stderr.on("data", (chunk) => {
             stderr += chunk.toString();
         });
         child.on("close", (exitCode) => finish(() => resolve({
@@ -73,6 +88,35 @@ export async function runBashCommand(command, options = {}) {
         child.on("error", (error) => finish(() => reject(new Error(`Failed to run bash command: ${error.message}`, { cause: error }))));
     });
 }
+export function parseBashVersion(output) {
+    const match = /version (\d+\.\d+\.\d+)/.exec(output);
+    return match?.[1];
+}
+export async function detectBashVersion() {
+    if (versionDetected) {
+        return cachedBashVersion;
+    }
+    if (pendingBashVersion) {
+        return pendingBashVersion;
+    }
+    pendingBashVersion = (async () => {
+        try {
+            const result = await runBashCommand("bash --version");
+            cachedBashVersion = parseBashVersion(result.stdout);
+        }
+        catch {
+            cachedBashVersion = undefined;
+        }
+        versionDetected = true;
+        return cachedBashVersion;
+    })();
+    try {
+        return await pendingBashVersion;
+    }
+    finally {
+        pendingBashVersion = undefined;
+    }
+}
 export async function validateRalphLoop(projectDir) {
     const loopPath = join(projectDir, RALPH_LOOP_PATH);
     if (!(await exists(loopPath))) {
@@ -80,9 +124,14 @@ export async function validateRalphLoop(projectDir) {
     }
 }
 export function spawnRalphLoop(projectDir, platformId, options) {
+    const env = { ...process.env, PLATFORM_DRIVER: platformId };
+    if (options.reviewEnabled) {
+        env.REVIEW_ENABLED = "true";
+        env.REVIEW_INTERVAL = "5";
+    }
     const child = spawn(cachedBashCommand ?? "bash", [BASH_RALPH_LOOP_PATH], {
         cwd: projectDir,
-        env: { ...process.env, PLATFORM_DRIVER: platformId },
+        env,
         stdio: options.inheritStdio ? "inherit" : ["ignore", "pipe", "pipe"],
         detached: process.platform !== "win32",
         windowsHide: true,

package/dist/run/run-dashboard.js

@@ -1,11 +1,13 @@
 import { createRefreshCallback } from "../watch/dashboard.js";
 import { createTerminalFrameWriter } from "../watch/frame-writer.js";
 import { FileWatcher } from "../watch/file-watcher.js";
-export function renderStatusBar(ralph) {
+import { renderFooterLine } from "../watch/renderer.js";
+export function renderStatusBar(ralph, reviewEnabled) {
     const pid = ralph.child.pid ?? "?";
+    const badge = reviewEnabled ? " [review]" : "";
     switch (ralph.state) {
         case "running":
-            return `Ralph: running (PID ${pid}) | q: stop/detach`;
+            return `Ralph: running (PID ${pid})${badge} | q: stop/detach`;
         case "stopped":
             return `Ralph: stopped (exit ${ralph.exitCode ?? "?"}) | q: quit`;
         case "detached":
@@ -16,27 +18,25 @@ export function renderQuitPrompt() {
     return "Stop (s) | Detach (d) | Cancel (c)";
 }
 export async function startRunDashboard(options) {
-    const { projectDir, interval, ralph } = options;
+    const { projectDir, interval, ralph, reviewEnabled } = options;
     const frameWriter = createTerminalFrameWriter();
-    let statusBarText = renderStatusBar(ralph);
     let showingPrompt = false;
     let stopped = false;
-    const decorateFrame = (frame) => {
-        const bar = showingPrompt ? renderQuitPrompt() : statusBarText;
-        return `${frame}\n${bar}`;
+    const footerRenderer = (lastUpdated, cols) => {
+        const leftText = showingPrompt ? renderQuitPrompt() : renderStatusBar(ralph, reviewEnabled);
+        return renderFooterLine(leftText, `Updated: ${lastUpdated.toISOString().slice(11, 19)}`, cols);
     };
     const refresh = createRefreshCallback(projectDir, (frame) => {
         if (stopped) {
             return;
         }
         frameWriter.write(frame);
-    }, { decorateFrame });
+    }, { footerRenderer });
     const watcher = new FileWatcher(refresh, interval);
     ralph.onExit(() => {
         if (stopped) {
             return;
         }
-        statusBarText = renderStatusBar(ralph);
         void refresh();
     });
     return new Promise((resolve) => {
@@ -101,6 +101,7 @@ export async function startRunDashboard(options) {
             }
             resolve();
         };
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- setRawMode absent in pseudo-TTY
         if (process.stdin.isTTY && process.stdin.setRawMode) {
             process.stdin.setRawMode(true);
             process.stdin.resume();

package/dist/transition/artifact-scan.js

@@ -2,9 +2,8 @@ import { readdir } from "node:fs/promises";
 import { relative } from "node:path";
 import { findArtifactsDir } from "./artifacts.js";
 import { ARTIFACT_DEFINITIONS } from "../utils/artifact-definitions.js";
-function getCursorNextAction() {
-    return "Read _bmad/COMMANDS.md and ask Cursor to run the BMAD master agent for the next BMAD workflow";
-}
+import { getPlatform } from "../platform/registry.js";
+import { getPlatformAnalysisHint, getPlatformArchitectureHint, getPlatformEpicsStoriesHint, getPlatformMasterAgentHint, getPlatformPrdHint, getPlatformReadinessHint, } from "../platform/guidance.js";
 export function classifyArtifact(filename) {
     for (const rule of ARTIFACT_DEFINITIONS) {
         if (rule.pattern.test(filename)) {
@@ -44,29 +43,36 @@ export function getMissing(phases) {
 }
 export function suggestNext(phases, detectedPhase, platformId) {
     const foundNames = new Set([...phases[1], ...phases[2], ...phases[3]].map((a) => a.name));
-    if (platformId === "cursor") {
+    const platform = platformId ? getPlatform(platformId) : null;
+    if (platform && platform.commandDelivery.kind === "index") {
         const allPlanningArtifactsPresent = foundNames.has("PRD") &&
             foundNames.has("Architecture") &&
             foundNames.has("Epics & Stories") &&
             foundNames.has("Readiness Report");
         if (!allPlanningArtifactsPresent) {
-            return getCursorNextAction();
+            return getPlatformMasterAgentHint(platform);
         }
     }
     if (detectedPhase <= 1 && phases[1].length === 0) {
-        return "Run /analyst to start analysis";
+        return platform ? getPlatformAnalysisHint(platform) : "Run /analyst to start analysis";
     }
     if (!foundNames.has("PRD")) {
-        return "Run /create-prd to create the PRD";
+        return platform ? getPlatformPrdHint(platform) : "Run /create-prd to create the PRD";
     }
     if (!foundNames.has("Architecture")) {
-        return "Run /architect to create architecture";
+        return platform
+            ? getPlatformArchitectureHint(platform)
+            : "Run /architect to create architecture";
     }
     if (!foundNames.has("Epics & Stories")) {
-        return "Run /create-epics-stories to define epics and stories";
+        return platform
+            ? getPlatformEpicsStoriesHint(platform)
+            : "Run /create-epics-stories to define epics and stories";
     }
     if (!foundNames.has("Readiness Report")) {
-        return "Run /architect to generate readiness report";
+        return platform
+            ? getPlatformReadinessHint(platform)
+            : "Run /architect to generate readiness report";
     }
     return "Run: bmalph implement";
 }

package/dist/transition/context.js

@@ -11,7 +11,7 @@ export function extractSectionWithInfo(content, headingPattern, maxLength = SECT
     // Determine heading level from the match
     const headingLevelMatch = match[0].match(/^(#{1,6})\s/);
     const level = headingLevelMatch ? headingLevelMatch[1].length : 2;
-    const startIndex = (match.index ?? 0) + match[0].length;
+    const startIndex = match.index + match[0].length;
     const rest = content.slice(startIndex);
     // Find next heading of same or higher level
     const nextHeadingPattern = new RegExp(`^#{1,${level}}\\s`, "m");

package/dist/utils/constants.js

@@ -40,8 +40,10 @@ export const BMAD_DIR = "_bmad";
 export const BMALPH_DIR = "bmalph";
 /** BMAD output directory (planning artifacts) */
 export const BMAD_OUTPUT_DIR = "_bmad-output";
-/** Skills directory (for skills-based command delivery) */
-export const SKILLS_DIR = ".agents/skills";
+/** Skills directory used by the Codex platform */
+export const CODEX_SKILLS_DIR = ".agents/skills";
+/** Skills directory used by the OpenCode platform */
+export const OPENCODE_SKILLS_DIR = ".opencode/skills";
 /** Prefix for bmalph-managed skill directories */
 export const SKILLS_PREFIX = "bmad-";
 /** bmalph state subdirectory (inside BMALPH_DIR) */
@@ -51,6 +53,28 @@ export const CONFIG_FILE = "bmalph/config.json";
 /** Ralph status file path */
 export const RALPH_STATUS_FILE = ".ralph/status.json";
 // =============================================================================
+// Ralph status mapping
+// =============================================================================
+/**
+ * Maps raw Ralph bash status strings to normalized status values.
+ * Single source of truth — used by both validate.ts and ralph-runtime-state.ts.
+ */
+export const RALPH_STATUS_MAP = {
+    running: "running",
+    halted: "blocked",
+    stopped: "blocked",
+    completed: "completed",
+    success: "completed",
+    graceful_exit: "completed",
+    paused: "blocked",
+    error: "blocked",
+};
+// =============================================================================
+// Gitignore entries managed by bmalph
+// =============================================================================
+/** Entries bmalph adds to .gitignore during init and checks during doctor */
+export const GITIGNORE_ENTRIES = [".ralph/logs/", "_bmad-output/"];
+// =============================================================================
 // Dashboard constants
 // =============================================================================
 /** Default dashboard refresh interval in milliseconds */

package/dist/utils/github.js

@@ -132,9 +132,10 @@ export class GitHubClient {
                 typeof data.sha !== "string" ||
                 !("commit" in data) ||
                 !data.commit ||
-                typeof data.commit?.message !== "string" ||
-                !data.commit?.author ||
-                typeof data.commit?.author?.date !== "string") {
+                typeof data.commit.message !==
+                    "string" ||
+                !data.commit.author ||
+                typeof data.commit.author.date !== "string") {
                 return {
                     success: false,
                     error: {

package/dist/utils/ralph-runtime-state.js

@@ -1,22 +1,12 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { RALPH_DIR, RALPH_STATUS_FILE } from "./constants.js";
+import { RALPH_DIR, RALPH_STATUS_FILE, RALPH_STATUS_MAP } from "./constants.js";
 import { isEnoent } from "./errors.js";
 import { validateCircuitBreakerState, validateRalphLoopStatus, validateRalphSession, } from "./validate.js";
 const RALPH_SESSION_FILE = ".ralph_session";
 const CIRCUIT_BREAKER_STATE_FILE = ".circuit_breaker_state";
 const CAMEL_CASE_CORE_KEYS = ["loopCount", "tasksCompleted", "tasksTotal"];
 const SNAKE_CASE_CORE_KEYS = ["loop_count", "tasks_completed", "tasks_total"];
-const RAW_RALPH_STATUS_MAP = {
-    running: "running",
-    halted: "blocked",
-    stopped: "blocked",
-    completed: "completed",
-    success: "completed",
-    graceful_exit: "completed",
-    paused: "blocked",
-    error: "blocked",
-};
 export async function readRalphRuntimeStatus(projectDir) {
     const path = join(projectDir, RALPH_STATUS_FILE);
     const raw = await readRuntimeJson(path);
@@ -149,9 +139,9 @@ function validateRalphSnakeCaseStatus(data) {
     if (typeof data.status !== "string") {
         throw new Error("ralphSnakeCaseStatus.status must be a string");
     }
-    const mappedStatus = RAW_RALPH_STATUS_MAP[data.status] ?? undefined;
+    const mappedStatus = RALPH_STATUS_MAP[data.status];
     if (mappedStatus === undefined) {
-        throw new Error(`ralphSnakeCaseStatus.status must be one of: ${Object.keys(RAW_RALPH_STATUS_MAP).join(", ")}`);
+        throw new Error(`ralphSnakeCaseStatus.status must be one of: ${Object.keys(RALPH_STATUS_MAP).join(", ")}`);
     }
     if ("tasks_completed" in data && typeof data.tasks_completed !== "number") {
         throw new Error("ralphSnakeCaseStatus.tasks_completed must be a number");

package/dist/utils/validate.js

@@ -1,5 +1,5 @@
 import { PLATFORM_IDS } from "../platform/types.js";
-import { DEFAULT_INTERVAL_MS, MAX_PROJECT_NAME_LENGTH, MIN_INTERVAL_MS } from "./constants.js";
+import { DEFAULT_INTERVAL_MS, MAX_PROJECT_NAME_LENGTH, MIN_INTERVAL_MS, RALPH_STATUS_MAP, } from "./constants.js";
 const VALID_STATUSES = ["planning", "implementing", "completed"];
 // Invalid filesystem characters (Windows + POSIX)
 const INVALID_FS_CHARS = /[<>:"/\\|?*]/;
@@ -178,21 +178,15 @@ export function validateRalphLoopStatus(data) {
         tasksTotal: data.tasksTotal,
     };
 }
-const BASH_STATUS_MAP = {
-    running: "running",
-    halted: "blocked",
-    stopped: "blocked",
-    completed: "completed",
-    success: "completed",
-    graceful_exit: "completed",
-};
 // Loose normalization helper for non-runtime consumers and legacy tests.
 // Runtime-file parsing uses the stricter contract in ralph-runtime-state.ts.
 export function normalizeRalphStatus(data) {
     assertObject(data, "normalizeRalphStatus");
     const loopCount = typeof data.loop_count === "number" ? data.loop_count : 0;
     const rawStatus = typeof data.status === "string" ? data.status : undefined;
-    const status = (rawStatus !== undefined ? BASH_STATUS_MAP[rawStatus] : undefined) ?? "unknown";
+    const status = (rawStatus !== undefined
+        ? RALPH_STATUS_MAP[rawStatus]
+        : undefined) ?? "unknown";
     return {
         loopCount,
         status,

package/dist/watch/dashboard.js

@@ -6,27 +6,38 @@ export function createRefreshCallback(projectDir, write, options = {}) {
     const now = options.now ?? (() => new Date());
     let lastMeaningfulUpdate;
     let lastRenderedBody;
+    const renderOptions = options.footerRenderer
+        ? { footerRenderer: options.footerRenderer }
+        : undefined;
     return async () => {
         const state = await readDashboardState(projectDir);
         if (lastMeaningfulUpdate === undefined) {
             lastMeaningfulUpdate = now();
         }
-        let body = renderDashboard({
+        let frame = renderDashboard({
             ...state,
             lastUpdated: lastMeaningfulUpdate,
-        });
+        }, undefined, renderOptions);
+        let body = stripFooterLine(frame);
         if (lastRenderedBody !== undefined && body !== lastRenderedBody) {
             lastMeaningfulUpdate = now();
-            body = renderDashboard({
+            frame = renderDashboard({
                 ...state,
                 lastUpdated: lastMeaningfulUpdate,
-            });
+            }, undefined, renderOptions);
+            body = stripFooterLine(frame);
         }
         lastRenderedBody = body;
-        const frame = options.decorateFrame ? options.decorateFrame(body) : body;
         write(frame);
     };
 }
+function stripFooterLine(frame) {
+    const footerIndex = frame.lastIndexOf("\n");
+    if (footerIndex === -1) {
+        return frame;
+    }
+    return frame.slice(0, footerIndex);
+}
 export async function startDashboard(options) {
     const { projectDir, interval } = options;
     const frameWriter = createTerminalFrameWriter();
@@ -61,6 +72,7 @@ export async function startDashboard(options) {
             }
             resolve();
         };
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- setRawMode absent in pseudo-TTY
         if (process.stdin.isTTY && process.stdin.setRawMode) {
             process.stdin.setRawMode(true);
             process.stdin.resume();

package/dist/watch/renderer.js

@@ -311,6 +311,23 @@ export function renderAnalysisPanel(analysis, cols) {
     ];
     return box("Last Analysis", lines, cols);
 }
+export function renderReviewPanel(review, cols) {
+    if (!review) {
+        return "";
+    }
+    const safeSeverity = sanitizeExternalText(review.severity);
+    const severityColor = safeSeverity === "CRITICAL" || safeSeverity === "HIGH"
+        ? chalk.red
+        : safeSeverity === "MEDIUM"
+            ? chalk.yellow
+            : chalk.green;
+    const safeSummary = sanitizeExternalText(review.summary);
+    const lines = [
+        `Severity: ${severityColor(safeSeverity)}    Issues: ${String(review.issuesFound)}`,
+        safeSummary ? chalk.dim(safeSummary.slice(0, 70)) : "",
+    ].filter(Boolean);
+    return box("Review Findings", lines, cols);
+}
 export function renderLogsPanel(logs, cols) {
     if (logs.length === 0) {
         return box("Recent Activity", [chalk.dim("No activity yet")], cols);
@@ -339,9 +356,7 @@ export function renderLiveLogPanel(liveLog, cols) {
     });
     return box("Live Output", lines, cols);
 }
-export function renderFooter(lastUpdated, cols) {
-    const leftText = "q quit";
-    const rightText = `Updated: ${formatTime(lastUpdated)}`;
+export function renderFooterLine(leftText, rightText, cols) {
     const availableWidth = Math.max(0, cols - 1);
     const minimumWidth = displayWidth(leftText) + 1 + displayWidth(rightText);
     if (availableWidth < minimumWidth) {
@@ -350,6 +365,9 @@ export function renderFooter(lastUpdated, cols) {
     const gap = availableWidth - displayWidth(leftText) - displayWidth(rightText);
     return ` ${chalk.dim(leftText)}${" ".repeat(gap)}${chalk.dim(rightText)}`;
 }
+export function renderFooter(lastUpdated, cols) {
+    return renderFooterLine("q quit", `Updated: ${formatTime(lastUpdated)}`, cols);
+}
 function hasAnyData(state) {
     return (state.loop !== null ||
         state.circuitBreaker !== null ||
@@ -357,19 +375,22 @@ function hasAnyData(state) {
         state.analysis !== null ||
         state.execution !== null ||
         state.session !== null ||
+        state.review !== null ||
         state.recentLogs.length > 0 ||
         state.liveLog.length > 0);
 }
-export function renderDashboard(state, cols) {
+export function renderDashboard(state, cols, options = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- columns is undefined in non-TTY
     const width = cols ?? process.stdout.columns ?? 80;
     const referenceTime = state.lastUpdated.getTime();
+    const footerRenderer = options.footerRenderer ?? renderFooter;
     if (!hasAnyData(state)) {
         const lines = [];
         lines.push(renderHeader(width));
         lines.push("");
         lines.push(chalk.dim(padRight("  Waiting for Ralph to start...", width)));
         lines.push("");
-        lines.push(renderFooter(state.lastUpdated, width));
+        lines.push(footerRenderer(state.lastUpdated, width));
         return lines.join("\n");
     }
     const sections = [];
@@ -379,11 +400,15 @@ export function renderDashboard(state, cols) {
     const rightPanel = renderStoriesPanel(state.stories, width);
     sections.push(renderSideBySide(leftPanel, rightPanel, width));
     sections.push(renderAnalysisPanel(state.analysis, width));
+    const reviewPanel = renderReviewPanel(state.review, width);
+    if (reviewPanel) {
+        sections.push(reviewPanel);
+    }
     if (state.execution !== null) {
         sections.push(renderLiveLogPanel(state.liveLog, width));
     }
     sections.push(renderLogsPanel(state.recentLogs, width));
-    sections.push(renderFooter(state.lastUpdated, width));
+    sections.push(footerRenderer(state.lastUpdated, width));
     return sections
         .join("\n")
         .split("\n")

package/dist/watch/state-reader.js

@@ -10,13 +10,14 @@ const LOG_LINE_PATTERN = /^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] \[(\w+)\] (
 const DEFAULT_MAX_LOG_LINES = 8;
 const TAIL_BYTES = 4096;
 export async function readDashboardState(projectDir) {
-    const [loop, circuitBreaker, stories, analysis, execution, session, recentLogs, liveLog] = await Promise.all([
+    const [loop, circuitBreaker, stories, analysis, execution, session, review, recentLogs, liveLog] = await Promise.all([
         readLoopInfo(projectDir),
         readCircuitBreakerInfo(projectDir),
         readStoryProgress(projectDir),
         readAnalysisInfo(projectDir),
         readExecutionProgress(projectDir),
         readSessionInfo(projectDir),
+        readReviewInfo(projectDir),
         readRecentLogs(projectDir),
         readLiveLog(projectDir),
     ]);
@@ -28,6 +29,7 @@ export async function readDashboardState(projectDir) {
         analysis,
         execution,
         session,
+        review,
         recentLogs,
         liveLog,
         ralphCompleted,
@@ -157,6 +159,23 @@ export async function readSessionInfo(projectDir) {
         lastUsed: result.value.last_used,
     };
 }
+export async function readReviewInfo(projectDir) {
+    try {
+        const data = await readJsonFile(join(projectDir, RALPH_DIR, ".review_findings.json"));
+        if (data === null)
+            return null;
+        const issuesFound = typeof data.issues_found === "number" ? data.issues_found : 0;
+        if (issuesFound === 0)
+            return null;
+        const severity = typeof data.severity === "string" ? data.severity : "LOW";
+        const summary = typeof data.summary === "string" ? data.summary : "";
+        return { issuesFound, severity, summary };
+    }
+    catch (err) {
+        debug(`Failed to read review info: ${formatError(err)}`);
+        return null;
+    }
+}
 const LIVE_LOG_MAX_LINES = 5;
 const LIVE_LOG_TAIL_BYTES = 2048;
 export async function readLiveLog(projectDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmalph",
-  "version": "2.7.7",
+  "version": "2.9.0",
   "description": "Unified AI Development Framework - BMAD phases with Ralph execution loop",
   "type": "module",
   "bin": {
@@ -22,6 +22,9 @@
     "fmt:fix": "prettier --write .",
     "type-check": "tsc --noEmit",
     "ci": "npm run type-check && npm run lint && npm run fmt:check && npm run build && npm run test:all",
+    "clean": "rm -rf dist",
+    "rebuild": "npm run clean && npm run build",
+    "prepack": "npm run build",
     "prepublishOnly": "npm run lint && npm run build && npm run test:all",
     "update-bundled": "bash scripts/update-bundled.sh"
   },
@@ -55,13 +58,16 @@
   "files": [
     "bin/",
     "dist/",
+    "!dist/**/*.map",
     "bmad/",
     "ralph/",
     "slash-commands/",
     "bundled-versions.json"
   ],
   "dependencies": {
-    "@inquirer/prompts": "^8.3.0",
+    "@inquirer/confirm": "^5.1.9",
+    "@inquirer/input": "^4.1.9",
+    "@inquirer/select": "^4.2.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.2"
   },