bmalph 2.10.0 → 2.11.0

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";
@@ -40,7 +40,11 @@ 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);
     }

package/dist/run/ralph-process.js

@@ -123,6 +123,18 @@ 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.reviewMode) {

package/dist/run/run-dashboard.js

@@ -1,3 +1,4 @@
+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";
@@ -9,7 +10,7 @@ export function renderStatusBar(ralph, reviewMode) {
         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})`;
     }

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.10.0",
+  "version": "2.11.0",
   "description": "Unified AI Development Framework - BMAD phases with Ralph execution loop",
   "type": "module",
   "bin": {

package/ralph/lib/response_analyzer.sh

@@ -817,14 +817,6 @@ parse_json_response() {
         has_completion_signal="true"
     fi
 
-    # Boost confidence based on structured data availability
-    if [[ "$has_result_field" == "true" ]]; then
-        confidence=$((confidence + 20))  # Structured response boost
-    fi
-    if [[ $progress_count -gt 0 ]]; then
-        confidence=$((confidence + progress_count * 5))  # Progress indicators boost
-    fi
-
     # Write normalized result using jq for safe JSON construction
     # String fields use --arg (auto-escapes), numeric/boolean use --argjson
     jq -n \
@@ -844,12 +836,14 @@ parse_json_response() {
         --argjson permission_denial_count "$permission_denial_count" \
         --argjson denied_commands "$denied_commands_json" \
         --arg tests_status "$tests_status" \
+        --argjson has_result_field "$has_result_field" \
         '{
             status: $status,
             exit_signal: $exit_signal,
             is_test_only: $is_test_only,
             is_stuck: $is_stuck,
             has_completion_signal: $has_completion_signal,
+            has_result_field: $has_result_field,
             files_modified: $files_modified,
             error_count: $error_count,
             summary: $summary,
@@ -888,6 +882,7 @@ analyze_response() {
     local has_progress=false
     local confidence_score=0
     local exit_signal=false
+    local format_confidence=0
     local work_summary=""
     local files_modified=0
     local tasks_completed_this_loop=0
@@ -920,6 +915,7 @@ analyze_response() {
             tasks_completed_this_loop=$(jq -r -j '.tasks_completed_this_loop // 0' "$json_parse_result_file" 2>/dev/null || echo "0")
             tests_status=$(jq -r -j '.tests_status // "UNKNOWN"' "$json_parse_result_file" 2>/dev/null || echo "UNKNOWN")
             local json_confidence=$(jq -r -j '.confidence' "$json_parse_result_file" 2>/dev/null || echo "0")
+            local json_has_result_field=$(jq -r -j '.has_result_field' "$json_parse_result_file" 2>/dev/null || echo "false")
             local session_id=$(jq -r -j '.session_id' "$json_parse_result_file" 2>/dev/null || echo "")
 
             # Extract permission denial fields (Issue #101)
@@ -933,11 +929,16 @@ analyze_response() {
                 [[ "${VERBOSE_PROGRESS:-}" == "true" ]] && echo "DEBUG: Persisted session ID: $session_id" >&2
             fi
 
-            # JSON parsing provides high confidence
+            # Separate format confidence from completion confidence (Issue #124)
+            if [[ "$json_has_result_field" == "true" ]]; then
+                format_confidence=100
+            else
+                format_confidence=80
+            fi
             if [[ "$exit_signal" == "true" ]]; then
                 confidence_score=100
             else
-                confidence_score=$((json_confidence + 50))
+                confidence_score=$json_confidence
             fi
 
             if [[ ! "$tasks_completed_this_loop" =~ ^-?[0-9]+$ ]]; then
@@ -993,6 +994,7 @@ analyze_response() {
                 --argjson is_stuck "$is_stuck" \
                 --argjson has_progress "$has_progress" \
                 --argjson files_modified "$files_modified" \
+                --argjson format_confidence "$format_confidence" \
                 --argjson confidence_score "$confidence_score" \
                 --argjson exit_signal "$exit_signal" \
                 --argjson tasks_completed_this_loop "$tasks_completed_this_loop" \
@@ -1013,6 +1015,7 @@ analyze_response() {
                         is_stuck: $is_stuck,
                         has_progress: $has_progress,
                         files_modified: $files_modified,
+                        format_confidence: $format_confidence,
                         confidence_score: $confidence_score,
                         exit_signal: $exit_signal,
                         tasks_completed_this_loop: $tasks_completed_this_loop,
@@ -1043,6 +1046,7 @@ analyze_response() {
     local ralph_status_json=""
     if ralph_status_json=$(extract_ralph_status_block_json "$output_content" 2>/dev/null); then
         ralph_status_block_found=true
+        format_confidence=70
 
         local status
         status=$(printf '%s' "$ralph_status_json" | jq -r -j '.status' 2>/dev/null)
@@ -1084,6 +1088,7 @@ analyze_response() {
 
     if [[ "$ralph_status_block_found" != "true" ]]; then
         # No status block found — fall back to heuristic analysis
+        format_confidence=30
 
         # 2. Detect completion keywords in natural language output
         for keyword in "${COMPLETION_KEYWORDS[@]}"; do
@@ -1197,7 +1202,11 @@ analyze_response() {
 
         if [[ $files_modified -gt 0 ]]; then
             has_progress=true
-            ((confidence_score+=20))
+            # Only boost completion confidence in heuristic path (Issue #124)
+            # RALPH_STATUS block is authoritative — git changes shouldn't inflate it
+            if [[ "$ralph_status_block_found" != "true" ]]; then
+                ((confidence_score+=20))
+            fi
         fi
     fi
 
@@ -1232,6 +1241,7 @@ analyze_response() {
         --argjson is_stuck "$is_stuck" \
         --argjson has_progress "$has_progress" \
         --argjson files_modified "$files_modified" \
+        --argjson format_confidence "$format_confidence" \
         --argjson confidence_score "$confidence_score" \
         --argjson exit_signal "$exit_signal" \
         --argjson tasks_completed_this_loop "$tasks_completed_this_loop" \
@@ -1252,6 +1262,7 @@ analyze_response() {
                 is_stuck: $is_stuck,
                 has_progress: $has_progress,
                 files_modified: $files_modified,
+                format_confidence: $format_confidence,
                 confidence_score: $confidence_score,
                 exit_signal: $exit_signal,
                 tasks_completed_this_loop: $tasks_completed_this_loop,
@@ -1309,9 +1320,8 @@ update_exit_signals() {
     fi
 
     # Update completion_indicators array (only when Claude explicitly signals exit)
-    # Note: Previously used confidence >= 60, but JSON mode always has confidence >= 70
-    # due to deterministic scoring (+50 for JSON format, +20 for result field).
-    # This caused premature exits after 5 loops. Now we respect Claude's explicit intent.
+    # Note: Format confidence (parse quality) is separated from completion confidence
+    # since Issue #124. Only exit_signal drives completion indicators, not confidence score.
     local exit_signal=$(jq -r -j '.analysis.exit_signal // false' "$analysis_file")
     if [[ "$has_permission_denials" != "true" && "$has_progress_tracking_mismatch" != "true" && "$exit_signal" == "true" ]]; then
         signals=$(echo "$signals" | jq ".completion_indicators += [$loop_number]")
@@ -1338,6 +1348,7 @@ log_analysis_summary() {
 
     local loop=$(jq -r -j '.loop_number' "$analysis_file")
     local exit_sig=$(jq -r -j '.analysis.exit_signal' "$analysis_file")
+    local format_conf=$(jq -r -j '.analysis.format_confidence // 0' "$analysis_file")
     local confidence=$(jq -r -j '.analysis.confidence_score' "$analysis_file")
     local test_only=$(jq -r -j '.analysis.is_test_only' "$analysis_file")
     local files_changed=$(jq -r -j '.analysis.files_modified' "$analysis_file")
@@ -1347,7 +1358,8 @@ log_analysis_summary() {
     echo -e "${BLUE}║           Response Analysis - Loop #$loop                 ║${NC}"
     echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}"
     echo -e "${YELLOW}Exit Signal:${NC}      $exit_sig"
-    echo -e "${YELLOW}Confidence:${NC}       $confidence%"
+    echo -e "${YELLOW}Parse quality:${NC}    $format_conf%"
+    echo -e "${YELLOW}Completion:${NC}       $confidence%"
     echo -e "${YELLOW}Test Only:${NC}        $test_only"
     echo -e "${YELLOW}Files Changed:${NC}    $files_changed"
     echo -e "${YELLOW}Summary:${NC}          $summary"

package/ralph/ralph_loop.sh

@@ -531,6 +531,20 @@ log_status() {
     echo "[$timestamp] [$level] $message" >> "$LOG_DIR/ralph.log"
 }
 
+# Human-readable label for a process exit code
+describe_exit_code() {
+    local code=$1
+    case "$code" in
+        0)   echo "completed" ;;
+        1)   echo "error" ;;
+        124) echo "timed out" ;;
+        130) echo "interrupted (SIGINT)" ;;
+        137) echo "killed (OOM or SIGKILL)" ;;
+        143) echo "terminated (SIGTERM)" ;;
+        *)   echo "error (exit $code)" ;;
+    esac
+}
+
 # Update status JSON for external monitoring
 update_status() {
     local loop_count=$1
@@ -538,6 +552,7 @@ update_status() {
     local last_action=$3
     local status=$4
     local exit_reason=${5:-""}
+    local driver_exit_code=${6:-""}
 
     jq -n \
         --arg timestamp "$(get_iso_timestamp)" \
@@ -548,6 +563,7 @@ update_status() {
         --arg status "$status" \
         --arg exit_reason "$exit_reason" \
         --arg next_reset "$(get_next_hour_time)" \
+        --arg driver_exit_code "$driver_exit_code" \
         '{
             timestamp: $timestamp,
             loop_count: $loop_count,
@@ -556,7 +572,8 @@ update_status() {
             last_action: $last_action,
             status: $status,
             exit_reason: $exit_reason,
-            next_reset: $next_reset
+            next_reset: $next_reset,
+            driver_exit_code: (if $driver_exit_code != "" then ($driver_exit_code | tonumber) else null end)
         }' > "$STATUS_FILE"
 
     # Merge quality gate status if results exist
@@ -632,6 +649,44 @@ validate_claude_permission_mode() {
     esac
 }
 
+validate_git_repo() {
+    if ! command -v git &>/dev/null; then
+        log_status "ERROR" "git is not installed or not on PATH."
+        echo ""
+        echo "Ralph requires git for progress detection."
+        echo ""
+        echo "Install git:"
+        echo "  macOS:   brew install git  (or: xcode-select --install)"
+        echo "  Ubuntu:  sudo apt-get install git"
+        echo "  Windows: https://git-scm.com/downloads"
+        echo ""
+        echo "After installing, run this command again."
+        return 1
+    fi
+
+    if ! git rev-parse --git-dir &>/dev/null 2>&1; then
+        log_status "ERROR" "No git repository found in $(pwd)."
+        echo ""
+        echo "Ralph requires a git repository for progress detection."
+        echo ""
+        echo "To fix this, run:"
+        echo "  git init && git add -A && git commit -m 'initial commit'"
+        return 1
+    fi
+
+    if ! git rev-parse HEAD &>/dev/null 2>&1; then
+        log_status "ERROR" "Git repository has no commits."
+        echo ""
+        echo "Ralph requires at least one commit for progress detection."
+        echo ""
+        echo "To fix this, run:"
+        echo "  git add -A && git commit -m 'initial commit'"
+        return 1
+    fi
+
+    return 0
+}
+
 warn_if_allowed_tools_ignored() {
     if driver_supports_tool_allowlist; then
         return 0
@@ -826,6 +881,51 @@ count_fix_plan_checkboxes() {
     printf '%s %s %s\n' "$completed_items" "$uncompleted_items" "$total_items"
 }
 
+# Extract the first unchecked task line from @fix_plan.md.
+# Returns the raw checkbox line trimmed of leading whitespace, capped at 100 chars.
+# Outputs empty string if no unchecked tasks exist or file is missing.
+# Args: $1 = path to @fix_plan.md (optional, defaults to $RALPH_DIR/@fix_plan.md)
+extract_next_fix_plan_task() {
+    local fix_plan_file="${1:-$RALPH_DIR/@fix_plan.md}"
+    [[ -f "$fix_plan_file" ]] || return 0
+    local line
+    line=$(grep -m 1 -E "^[[:space:]]*- \[ \]" "$fix_plan_file" 2>/dev/null || true)
+    # Trim leading whitespace
+    line="${line#"${line%%[![:space:]]*}"}"
+    # Trim trailing whitespace
+    line="${line%"${line##*[![:space:]]}"}"
+    printf '%s' "${line:0:100}"
+}
+
+# Collapse completed story detail lines in @fix_plan.md.
+# For each [x]/[X] story line, strips subsequent indented blockquote lines (  > ...).
+# Incomplete stories keep their detail lines intact.
+# Args: $1 = path to @fix_plan.md (modifies in place via atomic write)
+collapse_completed_stories() {
+    local fix_plan_file="${1:-$RALPH_DIR/@fix_plan.md}"
+    [[ -f "$fix_plan_file" ]] || return 0
+
+    local tmp_file="${fix_plan_file}.collapse_tmp"
+    local skipping=false
+
+    while IFS= read -r line || [[ -n "$line" ]]; do
+        if [[ "$line" =~ ^[[:space:]]*-[[:space:]]*\[[xX]\][[:space:]]*Story[[:space:]]+[0-9] ]]; then
+            skipping=true
+            printf '%s\n' "$line"
+            continue
+        fi
+
+        if $skipping && [[ "$line" =~ ^[[:space:]]+\> ]]; then
+            continue
+        fi
+
+        skipping=false
+        printf '%s\n' "$line"
+    done < "$fix_plan_file" > "$tmp_file"
+
+    mv "$tmp_file" "$fix_plan_file"
+}
+
 enforce_fix_plan_progress_tracking() {
     local analysis_file=$1
     local completed_before=$2
@@ -1241,11 +1341,17 @@ validate_allowed_tools() {
 # Provides loop-specific context via --append-system-prompt
 build_loop_context() {
     local loop_count=$1
+    local session_id="${2:-}"
     local context=""
 
     # Add loop number
     context="Loop #${loop_count}. "
 
+    # Signal session continuity when resuming a valid session
+    if [[ -n "$session_id" ]]; then
+        context+="Session continued — do NOT re-read spec files. Resume implementation. "
+    fi
+
     # Extract incomplete tasks from @fix_plan.md
     # Bug #3 Fix: Support indented markdown checkboxes with [[:space:]]* pattern
     if [[ -f "$RALPH_DIR/@fix_plan.md" ]]; then
@@ -1254,6 +1360,13 @@ build_loop_context() {
         local total_tasks=0
         read -r completed_tasks incomplete_tasks total_tasks < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
         context+="Remaining tasks: ${incomplete_tasks}. "
+
+        # Inject the next unchecked task to give the AI a clear directive
+        local next_task
+        next_task=$(extract_next_fix_plan_task "$RALPH_DIR/@fix_plan.md")
+        if [[ -n "$next_task" ]]; then
+            context+="Next: ${next_task}. "
+        fi
     fi
 
     # Add circuit breaker state
@@ -1293,10 +1406,81 @@ build_loop_context() {
         fi
     fi
 
+    # Add git diff summary from previous loop (last segment — truncated first if over budget)
+    if [[ -f "$RALPH_DIR/.loop_diff_summary" ]]; then
+        local diff_summary
+        diff_summary=$(head -c 150 "$RALPH_DIR/.loop_diff_summary" 2>/dev/null)
+        if [[ -n "$diff_summary" ]]; then
+            context+="${diff_summary}. "
+        fi
+    fi
+
     # Limit total length to ~500 chars
     echo "${context:0:500}"
 }
 
+# Capture a compact git diff summary after each loop iteration.
+# Writes to $RALPH_DIR/.loop_diff_summary for the next loop's build_loop_context().
+# Args: $1 = loop_start_sha (git HEAD at loop start)
+capture_loop_diff_summary() {
+    local loop_start_sha="${1:-}"
+    local summary_file="$RALPH_DIR/.loop_diff_summary"
+
+    # Clear previous summary
+    rm -f "$summary_file"
+
+    # Require git and a valid repo
+    if ! command -v git &>/dev/null || ! git rev-parse --git-dir &>/dev/null 2>&1; then
+        return 0
+    fi
+
+    local current_sha
+    current_sha=$(git rev-parse HEAD 2>/dev/null || echo "")
+    local numstat_output=""
+
+    if [[ -n "$loop_start_sha" && -n "$current_sha" && "$loop_start_sha" != "$current_sha" ]]; then
+        # Commits exist: union of committed + working tree changes, deduplicated by filename
+        numstat_output=$(
+            {
+                git diff --numstat "$loop_start_sha" HEAD 2>/dev/null
+                git diff --numstat HEAD 2>/dev/null
+                git diff --numstat --cached 2>/dev/null
+            } | awk -F'\t' '!seen[$3]++'
+        )
+    else
+        # No commits: staged + unstaged only
+        numstat_output=$(
+            {
+                git diff --numstat 2>/dev/null
+                git diff --numstat --cached 2>/dev/null
+            } | awk -F'\t' '!seen[$3]++'
+        )
+    fi
+
+    [[ -z "$numstat_output" ]] && return 0
+
+    # Format: Changed: file (+add/-del), file2 (+add/-del)
+    # Skip binary files (numstat shows - - for binary)
+    # Use tab separator — numstat output is tab-delimited (handles filenames with spaces)
+    local formatted
+    formatted=$(echo "$numstat_output" | awk -F'\t' '
+        $1 != "-" {
+            if (n++) printf ", "
+            printf "%s (+%s/-%s)", $3, $1, $2
+        }
+    ')
+
+    [[ -z "$formatted" ]] && return 0
+
+    local result="Changed: ${formatted}"
+    # Self-truncate to ~150 chars (144 content + "...")
+    if [[ ${#result} -gt 147 ]]; then
+        result="${result:0:144}..."
+    fi
+
+    echo "$result" > "$summary_file"
+}
+
 # Check if a code review should run this iteration
 # Returns 0 (true) when review is due, 1 (false) otherwise
 # Args: $1 = loop_count, $2 = fix_plan_completed_delta (optional, for ultimate mode)
@@ -1957,12 +2141,16 @@ get_live_stream_filter() {
 execute_claude_code() {
     local timestamp=$(date '+%Y-%m-%d_%H-%M-%S')
     local output_file="$LOG_DIR/claude_output_${timestamp}.log"
+    local stderr_file="$LOG_DIR/claude_stderr_${timestamp}.log"
     local loop_count=$1
     local calls_made=$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")
     calls_made=$((calls_made + 1))
     local fix_plan_completed_before=0
     read -r fix_plan_completed_before _ _ < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
 
+    # Clear previous diff summary to prevent stale context on early exit (#117)
+    rm -f "$RALPH_DIR/.loop_diff_summary"
+
     # Fix #141: Capture git HEAD SHA at loop start to detect commits as progress
     # Store in file for access by progress detection after Claude execution
     local loop_start_sha=""
@@ -1975,21 +2163,22 @@ execute_claude_code() {
     local timeout_seconds=$((CLAUDE_TIMEOUT_MINUTES * 60))
     log_status "INFO" "⏳ Starting $DRIVER_DISPLAY_NAME execution... (timeout: ${CLAUDE_TIMEOUT_MINUTES}m)"
 
+    # Initialize or resume session (must happen before build_loop_context
+    # so the session_id can gate the "session continued" signal)
+    local session_id=""
+    if [[ "$CLAUDE_USE_CONTINUE" == "true" ]] && supports_driver_sessions; then
+        session_id=$(init_claude_session)
+    fi
+
     # Build loop context for session continuity
     local loop_context=""
     if [[ "$CLAUDE_USE_CONTINUE" == "true" ]]; then
-        loop_context=$(build_loop_context "$loop_count")
+        loop_context=$(build_loop_context "$loop_count" "$session_id")
         if [[ -n "$loop_context" && "$VERBOSE_PROGRESS" == "true" ]]; then
             log_status "INFO" "Loop context: $loop_context"
         fi
     fi
 
-    # Initialize or resume session
-    local session_id=""
-    if [[ "$CLAUDE_USE_CONTINUE" == "true" ]] && supports_driver_sessions; then
-        session_id=$(init_claude_session)
-    fi
-
     # Live mode requires JSON output (stream-json) — override text format
     if [[ "$LIVE_OUTPUT" == "true" && "$CLAUDE_OUTPUT_FORMAT" == "text" ]]; then
         log_status "WARN" "Live mode requires JSON output format. Overriding text → json for this session."
@@ -2078,7 +2267,7 @@ execute_claude_code() {
         # read from stdin even in -p (print) mode, causing the process to hang
         set -o pipefail
         portable_timeout ${timeout_seconds}s stdbuf -oL "${LIVE_CMD_ARGS[@]}" \
-            < /dev/null 2>&1 | stdbuf -oL tee "$output_file" | stdbuf -oL jq --unbuffered -j "$jq_filter" 2>/dev/null | tee "$LIVE_LOG_FILE"
+            < /dev/null 2>"$stderr_file" | stdbuf -oL tee "$output_file" | stdbuf -oL jq --unbuffered -j "$jq_filter" 2>/dev/null | tee "$LIVE_LOG_FILE"
 
         # Capture exit codes from pipeline
         local -a pipe_status=("${PIPESTATUS[@]}")
@@ -2130,7 +2319,7 @@ execute_claude_code() {
             # stdin must be redirected from /dev/null because newer Claude CLI versions
             # read from stdin even in -p (print) mode, causing SIGTTIN suspension
             # when the process is backgrounded
-            if portable_timeout ${timeout_seconds}s "${CLAUDE_CMD_ARGS[@]}" < /dev/null > "$output_file" 2>&1 &
+            if portable_timeout ${timeout_seconds}s "${CLAUDE_CMD_ARGS[@]}" < /dev/null > "$output_file" 2>"$stderr_file" &
             then
                 :  # Continue to wait loop
             else
@@ -2145,7 +2334,7 @@ execute_claude_code() {
         # Note: Legacy mode doesn't use --allowedTools, so tool permissions
         # will be handled by Claude Code's default permission system
         if [[ "$use_modern_cli" == "false" ]]; then
-            if portable_timeout ${timeout_seconds}s $CLAUDE_CODE_CMD < "$PROMPT_FILE" > "$output_file" 2>&1 &
+            if portable_timeout ${timeout_seconds}s $CLAUDE_CODE_CMD < "$PROMPT_FILE" > "$output_file" 2>"$stderr_file" &
             then
                 :  # Continue to wait loop
             else
@@ -2204,6 +2393,9 @@ EOF
         exit_code=$?
     fi
 
+    # Expose the raw driver exit code to the main loop for status reporting
+    LAST_DRIVER_EXIT_CODE=$exit_code
+
     if [ $exit_code -eq 0 ]; then
         # Only increment counter on successful execution
         echo "$calls_made" > "$CALL_COUNT_FILE"
@@ -2227,6 +2419,11 @@ EOF
         read -r fix_plan_completed_after _ _ < <(count_fix_plan_checkboxes "$RALPH_DIR/@fix_plan.md")
         enforce_fix_plan_progress_tracking "$RESPONSE_ANALYSIS_FILE" "$fix_plan_completed_before" "$fix_plan_completed_after"
 
+        # Collapse completed story details so the agent doesn't re-read them
+        if [[ $fix_plan_completed_after -gt $fix_plan_completed_before ]]; then
+            collapse_completed_stories "$RALPH_DIR/@fix_plan.md"
+        fi
+
         # Run quality gates
         local exit_signal_for_gates
         exit_signal_for_gates=$(jq -r '.analysis.exit_signal // false' "$RESPONSE_ANALYSIS_FILE" 2>/dev/null || echo "false")
@@ -2289,6 +2486,9 @@ EOF
             fi
         fi
 
+        # Capture diff summary for next loop's context (#117)
+        capture_loop_diff_summary "$loop_start_sha"
+
         local has_errors="false"
 
         # Two-stage error detection to avoid JSON field false positives
@@ -2339,24 +2539,50 @@ EOF
             log_status "ERROR" "🚫 Claude API 5-hour usage limit reached"
             return 2  # Special return code for API limit
         else
-            log_status "ERROR" "❌ $DRIVER_DISPLAY_NAME execution failed, check: $output_file"
+            local exit_desc
+            exit_desc=$(describe_exit_code "$exit_code")
+            log_status "ERROR" "❌ $DRIVER_DISPLAY_NAME exited: $exit_desc (code $exit_code)"
+            if [[ -f "$stderr_file" && -s "$stderr_file" ]]; then
+                log_status "ERROR" "  stderr (last 3 lines): $(tail -3 "$stderr_file")"
+                log_status "ERROR" "  full stderr log: $stderr_file"
+            fi
             return 1
         fi
     fi
 }
 
-# Cleanup function
-cleanup() {
-    log_status "INFO" "Ralph loop interrupted. Cleaning up..."
+# Guard against double cleanup (EXIT fires after signal handler exits)
+_CLEANUP_DONE=false
+
+# EXIT trap — catches set -e failures and other unexpected exits
+_on_exit() {
+    local code=$?
+    [[ "$_CLEANUP_DONE" == "true" ]] && return
+    _CLEANUP_DONE=true
+    if [[ "$code" -ne 0 ]]; then
+        local desc
+        desc=$(describe_exit_code "$code")
+        log_status "ERROR" "Ralph loop exiting unexpectedly: $desc (code $code)"
+        update_status "$loop_count" "$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")" "unexpected_exit" "stopped" "$desc" "$code"
+    fi
+}
+
+# Signal handler — preserves signal identity in exit code
+_on_signal() {
+    local sig=$1
+    log_status "INFO" "Ralph loop interrupted by $sig. Cleaning up..."
     reset_session "manual_interrupt"
-    update_status "$loop_count" "$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")" "interrupted" "stopped"
-    exit 0
+    update_status "$loop_count" "$(cat "$CALL_COUNT_FILE" 2>/dev/null || echo "0")" "interrupted" "stopped" "$sig"
+    _CLEANUP_DONE=true
+    [[ "$sig" == "SIGINT" ]] && exit 130
+    exit 143
 }
 
-# Set up signal handlers
-trap cleanup SIGINT SIGTERM
+trap _on_exit EXIT
+trap '_on_signal SIGINT' SIGINT
+trap '_on_signal SIGTERM' SIGTERM
 
-# Global variable for loop count (needed by cleanup function)
+# Global variable for loop count (needed by trap handlers)
 loop_count=0
 
 # Main loop
@@ -2458,6 +2684,11 @@ main() {
         exit 1
     fi
 
+    # Check for git repository (required for progress detection)
+    if ! validate_git_repo; then
+        exit 1
+    fi
+
     # Initialize session tracking before entering the loop
     init_session_tracking
 
@@ -2602,7 +2833,12 @@ main() {
                 printf "\n"
             fi
         else
-            update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "failed" "error"
+            # Infrastructure failures (timeout, crash, OOM) intentionally bypass
+            # record_loop_result to avoid counting as agent stagnation. The circuit
+            # breaker only tracks progress during successful executions. (Issue #145)
+            local exit_desc
+            exit_desc=$(describe_exit_code "${LAST_DRIVER_EXIT_CODE:-1}")
+            update_status "$loop_count" "$(cat "$CALL_COUNT_FILE")" "failed" "error" "$exit_desc" "${LAST_DRIVER_EXIT_CODE:-}"
             log_status "WARN" "Execution failed, waiting 30 seconds before retry..."
             sleep 30
         fi

package/ralph/templates/PROMPT.md

@@ -4,21 +4,28 @@
 You are Ralph, an autonomous AI development agent working on a [YOUR PROJECT NAME] project.
 
 ## Current Objectives
-1. Study .ralph/specs/* to learn about the project specifications
-2. Review .ralph/@fix_plan.md for current priorities
-3. Implement the highest priority item using best practices
+1. Review .ralph/@fix_plan.md for current priorities
+2. Search the codebase for related code — especially which existing files need changes to integrate your work
+3. Implement the task from the loop context (or the first unchecked item in @fix_plan.md on the first loop)
 4. Use parallel subagents for complex tasks (max 100 concurrent)
 5. Run tests after each implementation
-6. Update documentation and the completed story checkbox in @fix_plan.md
+6. Update the completed story checkbox in @fix_plan.md and commit
+7. Read .ralph/specs/* ONLY if the task requires specific context you don't already have
 
 ## Key Principles
-- ONE task per loop - focus on the most important thing
+- Write code within the first few minutes of each loop
+- ONE task per loop — implement the task specified in the loop context
 - Search the codebase before assuming something isn't implemented
+- Creating new files is often only half the task — wire them into the existing application
 - Use subagents for expensive operations (file searching, analysis)
-- Write comprehensive tests with clear documentation
 - Toggle completed story checkboxes in .ralph/@fix_plan.md without rewriting story lines
 - 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 task
+
 ## Progress Tracking (CRITICAL)
 - Ralph tracks progress by counting story checkboxes in .ralph/@fix_plan.md
 - When you complete a story, change `- [ ]` to `- [x]` on that exact story line
@@ -306,7 +313,7 @@ RECOMMENDATION: Blocked on [specific dependency] - need [what's needed]
 - examples/: Example usage and test cases
 
 ## Current Task
-Follow .ralph/@fix_plan.md and choose the most important item to implement next.
-Use your judgment to prioritize what will have the biggest impact on project progress.
+Implement the task specified in the loop context.
+If no task is specified (first loop), pick the first unchecked item from .ralph/@fix_plan.md.
 
 Remember: Quality over speed. Build it right the first time. Know when you're done.