claude-fsd 1.5.8 → 1.5.10

package/bin/claudefsd

@@ -79,9 +79,7 @@ show_menu() {
         echo "  2) [Requires interview first]"
     fi
     
-    echo "  3) Development - Choose development approach:"
-    echo "    3a) Direct execution - Single-context parallel agents (small-medium projects)"
-    echo "    3b) Iterative development - Multi-cycle planning loop (large projects)"
+    echo "  3) Development - Run automated development"
     echo "  4) Exit"
     echo
     
@@ -173,7 +171,7 @@ open_with_editor() {
 # Check dependencies first
 check_dependencies
 
-# Function to check for updates (non-blocking)
+# Function to check for updates and auto-update if needed
 check_for_updates() {
     # Only check if we can reach npm registry quickly
     if timeout 2 npm view claude-fsd version >/dev/null 2>&1; then
@@ -182,8 +180,16 @@ check_for_updates() {
         
         if [ -n "$current_version" ] && [ -n "$latest_version" ] && [ "$current_version" != "$latest_version" ]; then
             echo -e "${YELLOW}📦 Update available: claude-fsd $current_version → $latest_version${NC}"
-            echo -e "${YELLOW}   Run: npm update -g claude-fsd${NC}"
-            echo
+            echo -e "${GREEN}🔄 Auto-updating claude-fsd...${NC}"
+            
+            # Attempt automatic update
+            if npm update -g claude-fsd >/dev/null 2>&1; then
+                echo -e "${GREEN}✅ Successfully updated to claude-fsd $latest_version${NC}"
+                echo
+            else
+                echo -e "${YELLOW}⚠️  Auto-update failed. Please run manually: npm update -g claude-fsd${NC}"
+                echo
+            fi
         fi
     fi
 }
@@ -254,23 +260,11 @@ if [ $# -eq 0 ]; then
             fi
             ;;
         3)
-            # Auto-detect development mode
-            echo -e "${GREEN}Auto-detecting development approach...${NC}"
+            # Run development mode
+            echo -e "${GREEN}Starting development mode...${NC}"
             echo
             exec "$(dirname "$0")/claudefsd-dev"
             ;;
-        3a)
-            # Direct execution mode
-            echo -e "${GREEN}Starting direct execution mode...${NC}"
-            echo
-            exec "$(dirname "$0")/claudefsd-dev" direct
-            ;;
-        3b)
-            # Iterative development mode
-            echo -e "${GREEN}Starting iterative development mode...${NC}"
-            echo
-            exec "$(dirname "$0")/claudefsd-dev" iterative
-            ;;
         4)
             echo "Goodbye!"
             exit 0
@@ -295,21 +289,6 @@ else
             shift
             exec "$(dirname "$0")/claudefsd-create-plan" "$@"
             ;;
-        dev-direct)
-            # Direct CLI access to direct mode
-            shift
-            exec "$(dirname "$0")/claudefsd-dev" direct "$@"
-            ;;
-        dev-iterative)
-            # Direct CLI access to iterative mode
-            shift
-            exec "$(dirname "$0")/claudefsd-dev" iterative "$@"
-            ;;
-        dev-mini)
-            # Legacy support - redirect to direct mode
-            shift
-            exec "$(dirname "$0")/claudefsd-dev" direct "$@"
-            ;;
         *)
             echo -e "${RED}Unknown command: $1${NC}"
             echo
@@ -318,9 +297,7 @@ else
             echo "Commands:"
             echo "  interview      - Interactive requirements gathering"
             echo "  create-plan    - Create plan from requirements or questions"
-            echo "  dev|run        - Run development mode (auto-detects approach)"
-            echo "  dev-direct     - Force direct execution mode"
-            echo "  dev-iterative  - Force iterative development mode"
+            echo "  dev|run        - Run automated development mode"
             echo
             echo "Run without arguments for interactive mode."
             exit 1

package/bin/claudefsd-create-plan

@@ -57,10 +57,12 @@ The CLAUDE-NOTES.md should contain:
 - Areas that may need future clarification
 
 The PLAN.md should contain:
-- Ordered list of development tasks with [ ] checkboxes
-- Each task should be specific and actionable
+- Master plan limited to 100 lines maximum
+- High-level sections with [ ] checkboxes for completion tracking
+- For complex projects, reference detailed sub-plans in separate files (docs/plan-section1.md, docs/plan-section2.md, etc.)
 - Include proportional infrastructure setup (basic linting + pre-commit hooks)
 - Group related tasks into logical phases
+- If the plan would exceed 100 lines, create a master plan with section references and detailed sub-plans
 
 INFRASTRUCTURE PROPORTIONALITY RULES:
 - Basic linter + pre-commit hooks: Always include for any project
@@ -112,8 +114,10 @@ Using your deep strategic reasoning, create a comprehensive project architecture
    - Long-term maintainability strategy
 
 2. IMPLEMENTATION PLAN (docs/PLAN.md):
+   - Master plan limited to 100 lines maximum with high-level sections
+   - For complex projects, create detailed sub-plans in separate files (docs/plan-section1.md, etc.)
    - Phased development approach with clear milestones
-   - Detailed task breakdown with dependencies
+   - Task breakdown with dependencies (detailed in sub-plans if needed)
    - Risk assessment for each phase
    - Testing strategy integrated into each phase
    - Infrastructure needs (proportional to project size)

package/bin/claudefsd-dev

@@ -1,63 +1,230 @@
 #!/bin/bash
 #
-# Main development dispatcher - routes to appropriate development mode
-# Usage: claudefsd-dev [direct|iterative]
-# 
-# Modes:
-# direct: Single-context parallel execution (small to medium projects)
-# iterative: Multi-iteration loop development (large projects)
+# Main development mode - intelligent task selection with parallel execution
+# Usage: claudefsd-dev
+#
+# Features:
+# - Fail-fast loop detection and "all done" prompt from iterative mode
+# - Direct parallel Task agent execution from direct mode
+# - Intelligent task planning and coordination
 #
-# Examples:
-#   claudefsd-dev          # Auto-detect mode from project brief
-#   claudefsd-dev direct   # Force direct execution mode
-#   claudefsd-dev iterative # Force iterative loop mode
 
 set -e
 
-# Parse command line arguments or auto-detect mode
-DEV_MODE="$1"
-if [ -z "$DEV_MODE" ]; then
-    # Auto-detect mode from BRIEF.md
-    if [ -f "BRIEF.md" ] || [ -f "docs/BRIEF.md" ]; then
-        BRIEF_FILE="BRIEF.md"
-        [ -f "docs/BRIEF.md" ] && BRIEF_FILE="docs/BRIEF.md"
+# Get the actual location of this script (resolving symlinks)
+if command -v realpath >/dev/null 2>&1; then
+    SCRIPT_PATH="$(realpath "$0")"
+elif command -v readlink >/dev/null 2>&1; then
+    # macOS doesn't have realpath by default, but has readlink
+    SCRIPT_PATH="$0"
+    while [ -L "$SCRIPT_PATH" ]; do
+        SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
+    done
+    SCRIPT_PATH="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)/$(basename "$SCRIPT_PATH")"
+else
+    # Fallback if neither command is available
+    SCRIPT_PATH="$(cd "$(dirname "$0")" && pwd)/$(basename "$0")"
+fi
+
+# Get the directory containing the script
+SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"
+
+# Check dependencies
+"$SCRIPT_DIR/claudefsd-check-dependencies"
+
+# Function to check for required files
+check_requirements() {
+    # Load find_brief_file function
+    source "$SCRIPT_DIR/claudefsd-find-brief"
+    brief_file=$(find_brief_file 2>/dev/null || echo "")
+    
+    if [ -z "$brief_file" ]; then
+        echo "No BRIEF.md file found in docs/ or root directory. Please create one first."
+        exit 1
+    fi
+    
+    if [ ! -f "docs/PLAN.md" ]; then
+        echo "No docs/PLAN.md file found. Please run 'claudefsd create-plan' first."
+        exit 1
+    fi
+}
+
+# Check requirements
+check_requirements
+
+# Add counter for loop iterations
+LOOP_COUNTER=0
+
+# Failure detection variables
+CONSECUTIVE_FAST_ITERATIONS=0
+MIN_ITERATION_TIME=300  # 5 minutes in seconds
+
+while true; do
+    # Record iteration start time
+    ITERATION_START_TIME=$(date +%s)
+    
+    # Increment loop counter
+    LOOP_COUNTER=$((LOOP_COUNTER + 1))
+    
+    mkdir -p logs
+    # Use a temporary directory for tmp files
+    mkdir -p tmp
+    export TMPDIR=tmp/
+    LOGFILE="logs/claude-dev-$(date +%Y%m%d_%H%M%S).txt"
+
+    echo "Logging to ${LOGFILE} ..."
+
+    echo -e "\033[32m==================================================================\033[0m"
+    echo -e "\033[32m== DEVELOPMENT MODE - ITERATION $LOOP_COUNTER\033[0m"
+    echo -e "\033[32m==================================================================\033[0m"
+
+    # Check if this is the 4th iteration for megathinking mode
+    if [ $((LOOP_COUNTER % 4)) -eq 0 ]; then
+        echo -e "\033[33m**** MEGATHINKING MODE ACTIVATED ****\033[0m"
+        echo -e "\033[33mThis is your 4th development cycle. Taking a step back for architectural planning.\033[0m"
+        MEGATHINKING_MODE="**** MEGATHINKING MODE ACTIVATED ****\nThis is your 4th development cycle. Before proceeding with the next task, please take a step back and use megathinking mode to architecturally plan the next phase of development. Consider the overall structure of the codebase, potential refactoring opportunities, design patterns, technical debt, and how the current work connects to broader project goals.\n\n"
+        CLAUDE_MODEL="opus"
+    else
+        MEGATHINKING_MODE=""
+        CLAUDE_MODEL="sonnet"
+    fi
+
+    # Build the development prompt combining intelligent task selection with parallel execution
+    DEVELOPMENT_PROMPT="$MEGATHINKING_MODE
+You are an elite development team leader working in an automated development environment. You combine intelligent task selection with parallel execution capabilities for maximum efficiency.
+
+**PROJECT CONTEXT:**
+$(source "$SCRIPT_DIR/claudefsd-find-brief" && brief_file=$(find_brief_file 2>/dev/null) && [ -n "$brief_file" ] && echo "=== PROJECT BRIEF ===" && cat "$brief_file" && echo "")
+$([ -f "docs/PLAN.md" ] && echo "=== DEVELOPMENT PLAN ===" && cat "docs/PLAN.md" && echo "")
+$([ -f "docs/REQUIREMENTS.md" ] && echo "=== REQUIREMENTS ===" && cat "docs/REQUIREMENTS.md" && echo "")
+$([ -f "docs/QUESTIONS.md" ] && echo "=== QUESTIONS ===" && cat "docs/QUESTIONS.md" && echo "")
+$([ -f "docs/CLAUDE-NOTES.md" ] && echo "=== TECHNICAL NOTES ===" && cat "docs/CLAUDE-NOTES.md" && echo "")
+$([ -f "README.md" ] && echo "=== README ===" && cat "README.md" && echo "")
+
+**IMPORTANT:** Before starting ANY work, you MUST read and understand:
+1. The project's CLAUDE.md file (if it exists) - this contains project-specific instructions
+2. The user's global CLAUDE.md file at ~/.claude/CLAUDE.md (if it exists) - this contains general development principles
+3. Ensure all your work follows the architectural and development guidelines from both files
+
+**CRITICAL ANTI-PATTERNS TO AVOID (from CLAUDE.md):**
+- NO CHEATING: Never disable tests, exclude files from compilation, or use silent fallbacks
+- FAIL FAST: Integration failures should throw exceptions, not return mock data
+- NO PRODUCTION FALLBACKS: Avoid try/catch blocks that hide errors with default values
+- NO BACKUP COPIES: Use git for version control, never create backup files
+- DELETE OLD CODE: Remove unused functions and scripts, keep the codebase clean
+
+**YOUR MISSION:**
+
+**PHASE 1: INTELLIGENT TASK ANALYSIS**
+1. Read the current docs/PLAN.md and identify all open tasks that need completion
+2. Analyze task dependencies and determine what can be done in parallel
+3. Consider the architectural implications of each task
+4. Prioritize tasks based on:
+   - Order in the plan (primary factor)
+   - Dependencies between tasks
+   - Risk and efficiency considerations
+   - Overall project architecture
+
+**PHASE 2: EXECUTION STRATEGY**
+Choose the optimal approach:
+
+**Option A: Single Focus Task** (for sequential dependencies or complex architectural work)
+- Select the highest priority open task
+- Implement with deep thinking and careful consideration
+- Update docs/PLAN.md to mark task as complete
+
+**Option B: Parallel Task Execution** (for independent tasks)
+- Identify 2-4 related but independent tasks that can be done simultaneously
+- Launch multiple Task agents with coordinated objectives
+- Each agent should understand the full project context
+- Ensure consistency across all parallel work
+
+**PHASE 3: COMPLETION CHECK**
+After completing work:
+1. Update docs/PLAN.md to reflect completed tasks
+2. Run any linters or tests specified in the project
+3. If ALL tasks in docs/PLAN.md are complete, respond with: **<ALL DONE>**
+
+**EXECUTION GUIDELINES:**
+- **BUILD BULLETPROOF**: Create robust solutions that handle edge cases
+- **STAY FOCUSED**: Only implement what's specified in docs/PLAN.md
+- **QUALITY FIRST**: Proper error handling, testing, and documentation
+- **ARCHITECTURAL THINKING**: Consider long-term maintainability
+
+**TASK AGENT COORDINATION:**
+When using parallel Task agents, ensure each one:
+- Has full project context and understands the architecture
+- Knows about related components they might need to integrate with
+- Follows all CLAUDE.md guidelines
+- Implements consistent code style and patterns
+- Handles proper error checking and edge cases
+
+**OUTPUT FORMAT:**
+1. **<task_analysis>**: List identified open tasks and selected approach
+2. **<execution>**: Details of your implementation work
+3. **<plan_updates>**: How you updated docs/PLAN.md to reflect progress
+4. **<completion_check>**: Status of remaining work, or **<ALL DONE>** if complete
+
+Begin by analyzing the current state of docs/PLAN.md and determining your execution strategy."
+
+    # Save the prompt to the log file first
+    echo "=== DEVELOPMENT PROMPT ===" > $LOGFILE
+    echo "$DEVELOPMENT_PROMPT" >> $LOGFILE
+    echo "=== END PROMPT ===" >> $LOGFILE
+    echo "" >> $LOGFILE
+    echo "=== OUTPUT ===" >> $LOGFILE
+
+    # Run claude and append output to the log file
+    echo "Running development with $CLAUDE_MODEL model..."
+    time claude --model $CLAUDE_MODEL --dangerously-skip-permissions -p "$DEVELOPMENT_PROMPT" 2>&1 | tee -a $LOGFILE
+
+    # Check if all tasks are complete
+    set +e
+    if grep -q "<ALL DONE>" $LOGFILE; then
+        echo -e "\033[32m==================================================================\033[0m"
+        echo -e "\033[32m== PROJECT COMPLETE - ALL TASKS FINISHED!\033[0m"
+        echo -e "\033[32m==================================================================\033[0m"
+        exit 0
+    fi
+    set -e
+
+    # Calculate iteration duration and check for failure patterns
+    ITERATION_END_TIME=$(date +%s)
+    ITERATION_DURATION=$((ITERATION_END_TIME - ITERATION_START_TIME))
+    
+    echo -e "\033[36mIteration $LOOP_COUNTER completed in ${ITERATION_DURATION}s\033[0m"
+    
+    # Check if iteration was suspiciously fast (likely failure mode)
+    if [ $ITERATION_DURATION -lt $MIN_ITERATION_TIME ]; then
+        CONSECUTIVE_FAST_ITERATIONS=$((CONSECUTIVE_FAST_ITERATIONS + 1))
+        echo -e "\033[33mWarning: Fast iteration detected (${ITERATION_DURATION}s < ${MIN_ITERATION_TIME}s threshold)\033[0m"
+        echo -e "\033[33mConsecutive fast iterations: $CONSECUTIVE_FAST_ITERATIONS/3\033[0m"
         
-        # Look for indicators of small/medium vs large projects
-        if grep -qi "simple\|small\|quick\|prototype\|poc\|minimal\|script\|tool\|utility\|feature\|module" "$BRIEF_FILE"; then
-            DEV_MODE="direct"
-        else
-            DEV_MODE="iterative"
+        # Exit if too many consecutive fast iterations (likely Claude API failure)
+        if [ $CONSECUTIVE_FAST_ITERATIONS -ge 3 ]; then
+            echo -e "\033[31m==================================================================\033[0m"
+            echo -e "\033[31m== FAILURE MODE DETECTED - THROTTLING ACTIVATED\033[0m"
+            echo -e "\033[31m==================================================================\033[0m"
+            echo -e "\033[31mDetected 3 consecutive iterations under ${MIN_ITERATION_TIME}s each.\033[0m"
+            echo -e "\033[31mThis usually indicates Claude API issues (token limits, etc).\033[0m"
+            echo -e "\033[31m\033[0m"
+            echo -e "\033[31mSuggested actions:\033[0m"
+            echo -e "\033[31m- Check your Claude API token limits\033[0m"
+            echo -e "\033[31m- Wait a few minutes and restart with: claudefsd dev\033[0m"
+            echo -e "\033[31m- Review logs in: logs/\033[0m"
+            echo -e "\033[31m==================================================================\033[0m"
+            exit 1
         fi
+        
+        # Add exponential backoff delay for fast iterations
+        BACKOFF_DELAY=$((CONSECUTIVE_FAST_ITERATIONS * 60))  # 1min, 2min, 3min
+        echo -e "\033[33mApplying backoff delay: ${BACKOFF_DELAY}s\033[0m"
+        sleep $BACKOFF_DELAY
     else
-        DEV_MODE="iterative"  # Default to iterative for safety
+        # Reset counter on successful iteration
+        CONSECUTIVE_FAST_ITERATIONS=0
+        echo -e "\033[32mNormal iteration timing - continuing...\033[0m"
     fi
-fi
 
-echo "Development mode: $DEV_MODE"
-
-# Route to appropriate development script
-case "$DEV_MODE" in
-    direct)
-        echo "Launching direct execution mode..."
-        exec "$(dirname "$0")/claudefsd-dev-direct"
-        ;;
-    iterative)
-        echo "Launching iterative development mode..."
-        exec "$(dirname "$0")/claudefsd-dev-iterative"
-        ;;
-    small)
-        # Legacy support - map to direct
-        echo "Legacy 'small' mode - redirecting to direct execution..."
-        exec "$(dirname "$0")/claudefsd-dev-direct"
-        ;;
-    large)
-        # Legacy support - map to iterative
-        echo "Legacy 'large' mode - redirecting to iterative development..."
-        exec "$(dirname "$0")/claudefsd-dev-iterative"
-        ;;
-    *)
-        echo "Unknown development mode: $DEV_MODE"
-        echo "Valid modes: direct, iterative"
-        exit 1
-        ;;
-esac
+    sleep 1
+done

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "claude-fsd",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "description": "Claude Full Self Drive tools for autonomous AI-powered development",
   "bin": {
     "claude-fsd": "bin/claude-fsd",
     "claudefsd": "bin/claudefsd",
     "claudefsd-check-dependencies": "bin/claudefsd-check-dependencies",
     "claudefsd-dev": "bin/claudefsd-dev",
-    "claudefsd-dev-direct": "bin/claudefsd-dev-direct",
-    "claudefsd-dev-iterative": "bin/claudefsd-dev-iterative",
     "claudefsd-find-brief": "bin/claudefsd-find-brief",
     "claudefsd-interview": "bin/claudefsd-interview",
     "claudefsd-analyze-brief": "bin/claudefsd-analyze-brief",

package/bin/claudefsd-dev-direct

@@ -1,181 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Get the actual location of this script (resolving symlinks)
-if command -v realpath >/dev/null 2>&1; then
-    SCRIPT_PATH="$(realpath "$0")"
-elif command -v readlink >/dev/null 2>&1; then
-    # macOS doesn't have realpath by default, but has readlink
-    SCRIPT_PATH="$0"
-    while [ -L "$SCRIPT_PATH" ]; do
-        SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
-    done
-    SCRIPT_PATH="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)/$(basename "$SCRIPT_PATH")"
-else
-    # Fallback if neither command is available
-    SCRIPT_PATH="$(cd "$(dirname "$0")" && pwd)/$(basename "$0")"
-fi
-
-# Get the directory containing the script
-SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"
-
-# Check dependencies
-"$SCRIPT_DIR/claudefsd-check-dependencies"
-
-# Use a temporary directory for tmp files
-tmp_dir="/tmp/claudefsd_tmp_$$"
-mkdir -p "$tmp_dir"
-cd "$tmp_dir"
-
-# Function to check for required files
-check_requirements() {
-    # Load find_brief_file function
-    source "$SCRIPT_DIR/claudefsd-find-brief"
-    cd "$OLDPWD"
-    brief_file=$(find_brief_file 2>/dev/null || echo "")
-    cd "$tmp_dir"
-    
-    
-    if [ -z "$brief_file" ]; then
-        echo "No BRIEF.md file found in docs/ or root directory. Please create one first."
-        exit 1
-    fi
-    
-    if [ ! -f "$OLDPWD/docs/PLAN.md" ]; then
-        echo "No docs/PLAN.md file found. Please run 'claudefsd create-plan' first."
-        exit 1
-    fi
-}
-
-# Check requirements
-check_requirements
-
-# Create logs directory
-mkdir -p "$OLDPWD/logs"
-LOGFILE="$OLDPWD/logs/claude-dev-direct-$(date +%Y%m%d_%H%M%S).txt"
-
-echo -e "\033[32m==================================================================\033[0m"
-echo -e "\033[32m== CLAUDE FSD DEV-DIRECT: PARALLEL EXECUTION MODE\033[0m"
-echo -e "\033[32m==================================================================\033[0m"
-echo
-echo "Direct execution mode uses parallel Task agents to complete projects"
-echo "in a single context. Optimized for small to medium-sized features."
-echo
-
-# Go back to the project directory
-cd "$OLDPWD"
-
-# Build the omnibus prompt  
-set +e  # Temporarily disable exit on error for prompt construction
-omnibus_prompt="You are an elite development team leader using Claude's Task agent capabilities for rapid parallel execution.
-
-**ANTI-GOLDPLATING DIRECTIVE**: This is direct execution mode optimized for small to medium projects. Focus on minimal viable solutions that meet requirements. Avoid over-engineering, unnecessary abstractions, or enterprise patterns unless explicitly required.
-
-PROJECT CONTEXT:
-$(cd "$OLDPWD" && source "$SCRIPT_DIR/claudefsd-find-brief" && brief_file=$(find_brief_file 2>/dev/null) && [ -n "$brief_file" ] && echo "=== PROJECT BRIEF ===" && cat "$brief_file" && echo "")
-$([ -f "$OLDPWD/docs/PLAN.md" ] && echo "=== DEVELOPMENT PLAN ===" && cat "$OLDPWD/docs/PLAN.md" && echo "")
-$([ -f "$OLDPWD/docs/REQUIREMENTS.md" ] && echo "=== REQUIREMENTS ===" && cat "$OLDPWD/docs/REQUIREMENTS.md" && echo "")
-$([ -f "$OLDPWD/docs/QUESTIONS.md" ] && echo "=== QUESTIONS ===" && cat "$OLDPWD/docs/QUESTIONS.md" && echo "")
-$([ -f "$OLDPWD/docs/CLAUDE-NOTES.md" ] && echo "=== TECHNICAL NOTES ===" && cat "$OLDPWD/docs/CLAUDE-NOTES.md" && echo "")
-$([ -f "$OLDPWD/README.md" ] && echo "=== README ===" && cat "$OLDPWD/README.md" && echo "")
-
-IMPORTANT: Before starting ANY work, you MUST read and understand:
-1. The project's CLAUDE.md file (if it exists) - this contains project-specific instructions
-2. The user's global CLAUDE.md file at ~/.claude/CLAUDE.md (if it exists) - this contains general development principles
-3. Ensure all your work follows the architectural and development guidelines from both files
-
-CRITICAL ANTI-PATTERNS TO AVOID (from CLAUDE.md):
-- NO CHEATING: Never disable tests, exclude files from compilation, or use silent fallbacks
-- FAIL FAST: Integration failures should throw exceptions, not return mock data
-- NO PRODUCTION FALLBACKS: Avoid try/catch blocks that hide errors with default values
-- NO BACKUP COPIES: Use git for version control, never create backup files
-- DELETE OLD CODE: Remove unused functions and scripts, keep the codebase clean
-
-DIRECT MODE CONSTRAINTS:
-- MINIMAL SOLUTIONS: Keep implementations simple and focused
-- NO GOLDPLATING: Don't add features not explicitly requested
-- SINGLE ENTRY POINTS: Prefer single scripts over complex architectures
-- AVOID OVER-ENGINEERING: No custom exceptions, elaborate hierarchies, or abstractions unless required
-- SPEED OVER ENTERPRISE: Get it working correctly first, optimize for enterprise patterns only if needed
-
-YOUR MISSION:
-1. Analyze the full project plan and identify all tasks that need to be completed
-2. Group related tasks that can be done in parallel by different agents
-3. Launch multiple Task agents concurrently to maximize efficiency
-4. Each agent should have a clear, specific brief about what to implement
-5. Coordinate the work to ensure consistency across all agents
-
-EXECUTION STRATEGY:
-- Read all project documentation first to understand the full scope
-- Create a mental map of dependencies between tasks
-- Launch agents for independent tasks in parallel batches
-- For dependent tasks, sequence them appropriately
-- Each agent should be given enough context to work autonomously
-
-TASK AGENT GUIDELINES FOR BRIEFS:
-When creating prompts for Task agents, ensure each one:
-- Has a clear, specific goal
-- Understands the project architecture and conventions
-- Knows about related components they might need to integrate with
-- Follows all CLAUDE.md guidelines
-- Includes relevant code style and testing requirements
-
-VERIFICATION:
-After all agents complete:
-- Review what was accomplished vs the plan
-- Run any tests or linters specified in the project
-- Summarize completion status and any issues encountered
-
-Start by analyzing the project and planning your parallel execution strategy.
-Then launch the Task agents to build this project rapidly and efficiently.
-
-Remember: This is a one-shot execution. Make it count!"
-
-set -e  # Re-enable exit on error
-
-echo "Running Claude dev-mini omnibus prompt..."
-echo "This will launch multiple parallel Task agents to complete the project..."
-echo
-
-# Run the omnibus prompt
-claude --dangerously-skip-permissions -p "$omnibus_prompt" 2>&1 | tee "$LOGFILE"
-
-echo
-echo -e "\033[32m==================================================================\033[0m"
-echo -e "\033[32m== DEV-MINI EXECUTION COMPLETE\033[0m"
-echo -e "\033[32m==================================================================\033[0m"
-echo
-
-# Run a verifier to check progress
-verifier_prompt="You are a project completion verifier.
-
-Review the work that was just completed and compare it against:
-$([ -f docs/PLAN.md ] && echo "=== ORIGINAL PLAN ===" && cat docs/PLAN.md && echo "")
-
-Your job:
-1. List what was successfully completed
-2. List what remains to be done (if anything)
-3. Estimate the completion percentage
-4. Identify any issues or errors encountered
-5. Recommend next steps:
-   - If mostly complete: suggest minor fixes
-   - If significantly incomplete: recommend switching to 'claudefsd dev' mode
-
-Be honest and thorough in your assessment.
-Format your response clearly with sections for completed tasks, remaining tasks, and recommendations."
-
-echo "Running completion verifier..."
-echo
-
-claude --dangerously-skip-permissions -p "$verifier_prompt" 2>&1 | tee -a "$LOGFILE"
-
-echo
-echo "Full log saved to: $LOGFILE"
-echo
-echo "If the project is incomplete, you can continue with:"
-echo "  claudefsd dev      # For iterative development mode"
-echo
-
-# Clean up
-rm -rf "$tmp_dir"

package/bin/claudefsd-dev-iterative

@@ -1,433 +0,0 @@
-#!/bin/bash
-#
-# Usage: claudefsd-dev [scale]
-# 
-# scale: "small" for simple projects (≤$2K scale, minimal solutions)
-#        "large" for complex projects ($1M+ scale, comprehensive solutions)
-#        If not specified, auto-detects from BRIEF.md content or defaults to "large"
-#
-# Examples:
-#   claudefsd-dev small    # Force small-scale development mode
-#   claudefsd-dev large    # Force large-scale development mode  
-#   claudefsd-dev          # Auto-detect scale from project brief
-
-set -e
-
-# Iterative mode is designed for large/complex projects
-PROJECT_SCALE="large"
-echo "Running iterative development mode (optimized for large/complex projects)"
-
-# Check dependencies
-$(dirname "$0")/claudefsd-check-dependencies
-
-# Add counter for loop iterations
-LOOP_COUNTER=0
-
-# Failure detection variables
-CONSECUTIVE_FAST_ITERATIONS=0
-MIN_ITERATION_TIME=300  # 5 minutes in seconds
-
-while true; do
-    # Record iteration start time
-    ITERATION_START_TIME=$(date +%s)
-    
-    # Increment loop counter
-    LOOP_COUNTER=$((LOOP_COUNTER + 1))
-    
-    mkdir -p logs
-    # Use a temporary directory for tmp files, as codex is sandboxed to this directory
-    mkdir -p tmp
-    export TMPDIR=tmp/
-    LOGFILE="logs/claude-$(date +%Y%m%d_%H%M%S).txt"
-
-    echo "Logging to ${LOGFILE}-* ..."
-
-    echo -e "\033[32m==================================================================\033[0m"
-    echo -e "\033[32m== PLANNING NEXT TASK\033[0m"
-    echo -e "\033[32m==================================================================\033[0m"
-
-    # Check if this is the 4th iteration for megathinking mode
-    if [ $((LOOP_COUNTER % 4)) -eq 0 ]; then
-        echo -e "\033[33m**** MEGATHINKING MODE ACTIVATED ****\033[0m"
-        echo -e "\033[33mThis is your 4th development cycle. Taking a step back for architectural planning.\033[0m"
-        MEGATHINKING_MODE="**** MEGATHINKING MODE ACTIVATED ****\nThis is your 4th development cycle. Before proceeding with the next task, please take a step back and use megathinking mode to architecturally plan the next phase of development. Consider the overall structure of the codebase, potential refactoring opportunities, design patterns, technical debt, and how the current work connects to broader project goals.\n\n"
-        CLAUDE_MODEL="opus"
-    else
-        MEGATHINKING_MODE=""
-        CLAUDE_MODEL="sonnet"
-    fi
-
-    # Define the planner prompt
-    PLANNER_PROMPT="
-$MEGATHINKING_MODE
-You are an AI assistant specialized in project management and software development workflows. Your task is to analyze project documentation and identify the next open task for a developer to work on.
-
-Please follow these steps to complete your task:
-
-1. Read the contents of docs/PLAN.md in order.
-2. Identify all open tasks that need to be done by the developer.
-3. Gather related context from docs/PLAN.md, docs/BRIEF.md (or BRIEF.md), docs/QUESTIONS.md, and docs/CLAUDE-NOTES.md.
-4. Consider the bigger picture of the project and potential impacts of each task.
-5. Evaluate the risk and efficiency of potential changes for each task.
-6. Prioritize the tasks based primarily on their order in the plan, but also factor in importance, risk, and efficiency.
-7. Select the most appropriate next task and formulate a response that includes the task description and relevant context.
-
-In your analysis, please consider the following:
-- Include any sub-bullet points or section information related to the tasks.
-- Think about how each task fits into the overall project goals.
-- Be aware of potential bottlenecks or situations where a single fix might resolve multiple issues.
-- Consider dependencies between tasks and how they might affect prioritization.
-
-Before providing your final task description, wrap your analysis inside <analysis> tags in your thinking block. This should include:
-- A list of all open tasks identified from docs/PLAN.md
-- An evaluation of each task's priority, risk, and efficiency
-- Consideration of task dependencies
-- Your reasoning for the final task selection, including how it fits into the project's broader context
-
-Your final output should be a clear, concise description of the next task, including relevant context and considerations. Use <task_description> tags for this output.
-
-If the plan is complete and there are no more tasks to be done, simply respond with <ALL DONE>.
-
-Example output structure:
-
-<analysis>
-[Your detailed analysis of the project documentation, list of open tasks, evaluation of each task, consideration of risks and impacts, and reasoning for task selection]
-</analysis>
-
-<task_description>
-[A concise description of the next task, including relevant context and considerations]
-</task_description>
-
-Please proceed with your analysis and task identification based on the project documentation. Your final output should consist only of the task description in <task_description> tags or <ALL DONE>, and should not duplicate or rehash any of the work you did in the analysis section.
-
-"
-
-    # Save the prompt to the log file first
-    echo "=== PROMPT ===" > $LOGFILE-planner
-    echo "$PLANNER_PROMPT" >> $LOGFILE-planner
-    echo "=== END PROMPT ===" >> $LOGFILE-planner
-    echo "" >> $LOGFILE-planner
-    echo "=== OUTPUT ===" >> $LOGFILE-planner
-
-    # Run claude and append output to the log file
-    time claude --model $CLAUDE_MODEL --dangerously-skip-permissions -p "$PLANNER_PROMPT" 2>&1 | tee -a $LOGFILE-planner
-
-    nexttask=$(cat $LOGFILE-planner)
-
-    echo -e "\033[32m==================================================================\033[0m"
-    echo -e "\033[32m== RUNNING DEVELOPER TASK\033[0m"
-    echo -e "\033[32m==================================================================\033[0m"
-
-    # Show megathinking banner for developer if active
-    if [ $((LOOP_COUNTER % 4)) -eq 0 ]; then
-        echo -e "\033[33m**** MEGATHINKING MODE ACTIVATED ****\033[0m"
-        echo -e "\033[33mThis is your 4th development cycle. Taking a step back for architectural planning.\033[0m"
-    fi
-
-    # Define thinking directive for iterative large-scale development
-    THINKING_DIRECTIVE="**ARCHITECTURAL THINKING DIRECTIVE**: Before beginning, engage in deep thinking about the task implications, architectural considerations, and optimal approach. This is iterative development for a large-scale project that demands thoroughness and quality."
-    
-    # Mild anti-goldplating constraints - build bulletproof systems but stay focused
-    SCALE_CONSTRAINTS="
-**ITERATIVE MODE GUIDELINES**:
-- BUILD BULLETPROOF: Create robust, well-architected solutions that handle edge cases
-- STAY FOCUSED: Don't add DevOps/CI/CD/infrastructure/monitoring unless it's explicitly in the plan
-- PLAN-DRIVEN: Only implement what's specified in docs/PLAN.md - no extra features
-- QUALITY FIRST: Proper error handling, testing, and documentation as specified
-- ARCHITECTURAL THINKING: Consider long-term maintainability and system design"
-
-    # Define the developer prompt
-    DEVELOPER_PROMPT="
-$MEGATHINKING_MODE
-$THINKING_DIRECTIVE
-
-You are an AI developer working within an automated development environment. Your role is to complete tasks, plan implementations, and maintain high-quality code. Here is the specific task you need to complete:
-
-<next_task>
-$nexttask
-</next_task>
-
-IMPORTANT: Before starting the task, you MUST read and understand:
-1. The project's CLAUDE.md file (if it exists) - this contains project-specific instructions
-2. The user's global CLAUDE.md file at ~/.claude/CLAUDE.md (if it exists) - this contains general development principles
-3. Ensure all your work follows the architectural and development guidelines from both files
-
-Please follow these steps to complete the task:
-
-1. **DEEP TASK ANALYSIS**: Analyze the task and plan your approach. In your thinking block, create an implementation plan wrapped in <implementation_plan> tags. Include:
-   - A detailed breakdown of the task into clear, actionable steps
-   - Whether this task would benefit from parallel agent decomposition
-   - For each step, identify:
-     * Potential challenges and proposed solutions
-     * Architectural implications
-     * How to adhere to clean code principles
-     * Impact on the overall system
-     * Defensive programming techniques to employ
-     * Potential edge cases and how to handle them
-     * A minimal, focused testing strategy (avoid extensive test infrastructure)
-
-2. **EXECUTION STRATEGY**: Choose between:
-   - **Single Agent Deep Work**: For focused sequential tasks requiring deep thinking
-   - **Parallel Agent Coordination**: For multi-faceted tasks that can be decomposed
-   
-   If choosing parallel agents, use the Task tool to spawn focused sub-agents:
-   - Core implementation agent
-   - Test coverage agent  
-   - Error handling agent
-   - Documentation agent
-
-3. Execute the necessary changes or Bash commands to complete the task. Use parallel agents for dev work when appropriate to increase efficiency.
-
-4. If a linter is defined for this project, run it and include the output in <linter_output> tags.
-
-5. Describe the changes you've made in <changes> tags. Include:
-   - A summary of implemented changes
-   - Explanation of architectural decisions
-   - Potential areas of concern or future considerations
-   - Confirmation of defensive programming techniques
-   - Verification that all failure modes throw exceptions
-   - How edge cases were addressed
-   - Outline of the testing strategy
-
-6. Add any questions for future reference to the QUESTIONS.md file. Summarize these additions in <questions_update> tags.
-
-7. Add any ideas for future improvements or features to the IDEAS.md file. Summarize these additions in <ideas_update> tags.
-
-Important guidelines:
-$SCALE_CONSTRAINTS
-
-- Simplicity: Delete old code, avoid hoarding. Use git for version control.
-- Brutal honesty: Disagree when needed. If something fails, let it fail visibly.
-- No cheating: Fix failing tests, don't skip them. No mocks without permission.
-- No production fallbacks: Never catch exceptions to return fallback values or silently handle integration failures.
-- Write real integration tests and run linters/tests frequently during development.
-- Stay on the current git branch if it's a feature branch.
-- Set up pre-commit hooks for basic SDLC protections.
-
-Your final output should follow this structure:
-
-<execution>
-[Details of executed changes or commands]
-</execution>
-
-<linter_output>
-[Linter output, if applicable]
-</linter_output>
-
-<changes>
-[Description of changes as outlined above]
-</changes>
-
-<questions_update>
-[Summary of questions added to QUESTIONS.md]
-</questions_update>
-
-<ideas_update>
-[Summary of ideas added to IDEAS.md]
-</ideas_update>
-
-Remember to adhere to the project's standards and best practices. Your work will be reviewed before being committed to the repository.
-
-Your final output should consist only of the execution details, linter output, changes description, questions update, and ideas update. Do not duplicate or rehash any of the work you did in the implementation planning section.
-"
-
-    # Save the prompt to the log file first
-    echo "=== PROMPT ===" > $LOGFILE-developer
-    echo "$DEVELOPER_PROMPT" >> $LOGFILE-developer
-    echo "=== END PROMPT ===" >> $LOGFILE-developer
-    echo "" >> $LOGFILE-developer
-    echo "=== OUTPUT ===" >> $LOGFILE-developer
-
-    # Run claude and append output to the log file
-    time claude --model $CLAUDE_MODEL --dangerously-skip-permissions -p "$DEVELOPER_PROMPT" | tee -a $LOGFILE-developer
-
-    echo -e "\033[32m==================================================================\033[0m"
-    echo -e "\033[32m== REVIEWING WORK (backgrounded)\033[0m"
-    echo -e "\033[32m==================================================================\033[0m"
-
-    # run the static code reviewer (codex can't do the git push part yet, so we need to follow up with claude after)
-    # also run it in the background because it's very slow
-    # Only run if codex is available
-    if command -v codex >/dev/null 2>&1; then
-        (codex --full-auto -m o3 -q "
-You are the team's static code reviewer.
-A developer has completed this task: $nexttask
-The developer's notes are at $LOGFILE-developer .
-
-Related docs:
-- docs/BRIEF.md (or BRIEF.md)
-- docs/PLAN.md
-- docs/QUESTIONS.md
-- docs/CLAUDE-NOTES.md
-- README.md
-
-Please review the task and make sure it's complete, and done to satisfaction.
-DO NOT trust the developer's notes, always review the code and build/test results yourself.
-Look for typical 'cheating' patterns:
-- Turning off unit tests or marking them as ignored
-- Taking files out of the compilation configuration  
-- Redefining the plan to skip tasks that aren't working
-- Silent exception handlers that return fallback values instead of failing
-- Try/catch blocks that log warnings but continue with empty/default data
-- Any code that catches integration failures and returns mock responses
-
-Also note: please avoid switching git branches - stay on the current branch, as
-long as it's a proper feature branch.
-
-If the task is complete, or there are a lot of pending changes, do a git commit.
-
-If the task is not complete, adjust the item in docs/PLAN.md with suggestions for 
-the developer to complete the task properly.
-
-If you have any questions of the user for the future, you can add them to QUESTIONS.md.
-If you have any ideas for the future, you can add them to IDEAS.md.
-" > $LOGFILE-reviewer) &
-    else
-        echo "Warning: codex not found, skipping background code review"
-        echo "Codex not available, skipping static code review" > $LOGFILE-reviewer
-    fi
-
-    echo -e "\033[32m==================================================================\033[0m"
-    echo -e "\033[32m== REVIEWING/TESTING/COMMITTING WORK\033[0m"
-    echo -e "\033[32m==================================================================\033[0m"
-
-    # Define the reviewer/tester prompt
-    REVIEWER_PROMPT="
-You are an expert megathinker static code reviewer tasked with thoroughly examining a developer's work on a specific task. Your goal is to ensure the task is complete and meets high-quality standards. 
-
-Here is the task the developer has completed:
-
-<task_description>
-${nexttask}
-</task_description>
-
-IMPORTANT: Before starting your review, you MUST read and understand:
-1. The project's CLAUDE.md file (if it exists) - this contains project-specific instructions
-2. The user's global CLAUDE.md file at ~/.claude/CLAUDE.md (if it exists) - this contains general development principles
-3. Verify that all recent changes comply with the architectural and development guidelines from both files
-
-To conduct your review, you have access to the following related documents:
-- docs/BRIEF.md (or BRIEF.md)
-- docs/PLAN.md
-- docs/QUESTIONS.md
-- docs/CLAUDE-NOTES.md
-- README.md
-
-The developer's notes are available in a file named ${LOGFILE}-developer.
-
-Instructions for your review process:
-
-1. Carefully read and understand the task description.
-2. Review the developer's notes, but do not trust them implicitly; verify them where possible.
-3. Examine the code and build/test results independently.
-4. Verify compliance with CLAUDE.md guidelines (both project and user files), paying special attention to:
-   - Simplicity and clean code principles
-   - No cheating patterns or production fallbacks
-   - Proper error handling (fail fast, no silent failures)
-   - Following architectural conventions
-5. Look for common cheating or misunderstanding patterns, including but not limited to:
-   - Disabling or ignoring unit tests
-   - Excluding files from compilation
-   - Redefining the plan to skip challenging tasks
-   - Using silent exception handlers that return fallback values
-   - Implementing try/catch blocks that log warnings but continue with empty/default data
-   - Catching integration failures and returning mock responses
-   - Build behaves differently for verifier than developer; this may come from them each running different scripts for compiling and running tests
-   - Committing with --no-verify to turn off the pre-commit checks; the checks may need to change to be more flexible, upon careful thinking, but they shouldn't just be turned off
-6. Stay on the current git branch, as long as it's a proper feature branch.
-7. If the task is incomplete or unsatisfactory, update docs/PLAN.md with detailed suggestions for the developer to complete the task properly.
-8. If you have questions for future consideration, add them to docs/QUESTIONS.md.
-9. If you have ideas for future improvements, add them to docs/IDEAS.md.
-
-Before providing your final review, please break down your review process and show your thought process inside <code_review_process> tags in your thinking block:
-
-1. Summarize the task description in your own words.
-2. List out the key documents you need to review.
-3. For each document, note down relevant quotes or information that pertain to the task.
-4. Check CLAUDE.md compliance - list specific guidelines that apply to this task and verify adherence.
-5. Explicitly look for any 'cheating' patterns and list any that you find.
-6. Consider arguments for and against the task being complete and of satisfactory quality.
-
-This will ensure a thorough and careful examination of the developer's work. It's OK for this section to be quite long.
-
-After your analysis, provide a summary of your findings and any necessary actions in the following format:
-
-<review_summary>
-Task Status: [Complete/Incomplete]
-Quality Assessment: [Satisfactory/Unsatisfactory]
-
-Key Findings:
-1. [Finding 1]
-2. [Finding 2]
-...
-
-Actions Taken:
-- [Action 1, e.g., 'Updated PLAN.md with suggestions for improvement']
-- [Action 2, e.g., 'Added question to QUESTIONS.md']
-...
-
-</review_summary>
-
-Please proceed with your thorough code review and analysis. Your final output should consist only of the review summary and should not duplicate or rehash any of the work you did in the thinking block.
-"
-
-    # Save the prompt to the log file first
-    echo "=== PROMPT ===" > $LOGFILE-tester
-    echo "$REVIEWER_PROMPT" >> $LOGFILE-tester
-    echo "=== END PROMPT ===" >> $LOGFILE-tester
-    echo "" >> $LOGFILE-tester
-    echo "=== OUTPUT ===" >> $LOGFILE-tester
-
-    # Run claude and append output to the log file
-    time claude --model $CLAUDE_MODEL --dangerously-skip-permissions -p "$REVIEWER_PROMPT" | tee -a $LOGFILE-tester
-
-    # Check if verifier has confirmed all tasks are truly complete
-    set +e
-    if grep -q "<VERIFIED_ALL_DONE>" $LOGFILE-tester; then
-        echo -e "\033[32mAll tasks verified complete by reviewer - project finished!\033[0m"
-        exit 0
-    fi
-    set -e
-
-    # Calculate iteration duration and check for failure patterns
-    ITERATION_END_TIME=$(date +%s)
-    ITERATION_DURATION=$((ITERATION_END_TIME - ITERATION_START_TIME))
-    
-    echo -e "\033[36mIteration $LOOP_COUNTER completed in ${ITERATION_DURATION}s\033[0m"
-    
-    # Check if iteration was suspiciously fast (likely failure mode)
-    if [ $ITERATION_DURATION -lt $MIN_ITERATION_TIME ]; then
-        CONSECUTIVE_FAST_ITERATIONS=$((CONSECUTIVE_FAST_ITERATIONS + 1))
-        echo -e "\033[33mWarning: Fast iteration detected (${ITERATION_DURATION}s < ${MIN_ITERATION_TIME}s threshold)\033[0m"
-        echo -e "\033[33mConsecutive fast iterations: $CONSECUTIVE_FAST_ITERATIONS/3\033[0m"
-        
-        # Exit if too many consecutive fast iterations (likely Claude API failure)
-        if [ $CONSECUTIVE_FAST_ITERATIONS -ge 3 ]; then
-            echo -e "\033[31m==================================================================\033[0m"
-            echo -e "\033[31m== FAILURE MODE DETECTED - THROTTLING ACTIVATED\033[0m"
-            echo -e "\033[31m==================================================================\033[0m"
-            echo -e "\033[31mDetected 3 consecutive iterations under ${MIN_ITERATION_TIME}s each.\033[0m"
-            echo -e "\033[31mThis usually indicates Claude API issues (token limits, etc).\033[0m"
-            echo -e "\033[31m\033[0m"
-            echo -e "\033[31mSuggested actions:\033[0m"
-            echo -e "\033[31m- Check your Claude API token limits\033[0m"
-            echo -e "\033[31m- Wait a few minutes and restart with: claude-fsd dev\033[0m"
-            echo -e "\033[31m- Review logs in: logs/\033[0m"
-            echo -e "\033[31m==================================================================\033[0m"
-            exit 1
-        fi
-        
-        # Add exponential backoff delay for fast iterations
-        BACKOFF_DELAY=$((CONSECUTIVE_FAST_ITERATIONS * 60))  # 1min, 2min, 3min
-        echo -e "\033[33mApplying backoff delay: ${BACKOFF_DELAY}s\033[0m"
-        sleep $BACKOFF_DELAY
-    else
-        # Reset counter on successful iteration
-        CONSECUTIVE_FAST_ITERATIONS=0
-        echo -e "\033[32mNormal iteration timing - continuing...\033[0m"
-    fi
-
-    sleep 1
-done
-
-

package/bin/claudefsd-dev-mini

@@ -1,148 +0,0 @@
-#!/bin/bash
-
-set -e
-
-# Check dependencies
-$(dirname "$0")/claudefsd-check-dependencies
-
-# Use a temporary directory for tmp files
-tmp_dir="/tmp/claudefsd_tmp_$$"
-mkdir -p "$tmp_dir"
-cd "$tmp_dir"
-
-# Function to check for required files
-check_requirements() {
-    # Load find_brief_file function
-    source "$(dirname "$0")/claudefsd-find-brief"
-    cd "$OLDPWD"
-    local brief_file=$(find_brief_file 2>/dev/null || echo "")
-    cd "$tmp_dir"
-    if [ -z "$brief_file" ]; then
-        echo "No BRIEF.md file found in docs/ or root directory. Please create one first."
-        exit 1
-    fi
-    
-    if [ ! -f "$OLDPWD/docs/PLAN.md" ]; then
-        echo "No docs/PLAN.md file found. Please run 'claudefsd create-plan' first."
-        exit 1
-    fi
-}
-
-# Check requirements
-check_requirements
-
-# Create logs directory
-mkdir -p "$OLDPWD/logs"
-LOGFILE="$OLDPWD/logs/claude-dev-mini-$(date +%Y%m%d_%H%M%S).txt"
-
-echo -e "\033[32m==================================================================\033[0m"
-echo -e "\033[32m== CLAUDE FSD DEV-MINI: FAST PARALLEL EXECUTION MODE\033[0m"
-echo -e "\033[32m==================================================================\033[0m"
-echo
-echo "This mode attempts to complete the entire project in one shot using"
-echo "parallel Task agents. Best for smaller projects that fit in context."
-echo
-
-# Go back to the project directory
-cd "$OLDPWD"
-
-# Build the omnibus prompt
-omnibus_prompt="You are an elite development team leader using Claude's Task agent capabilities for rapid parallel execution.
-
-PROJECT CONTEXT:
-$([ -f docs/BRIEF.md ] && echo "=== PROJECT BRIEF ===" && cat docs/BRIEF.md || [ -f BRIEF.md ] && echo "=== PROJECT BRIEF ===" && cat BRIEF.md && echo "")
-$([ -f docs/PLAN.md ] && echo "=== DEVELOPMENT PLAN ===" && cat docs/PLAN.md && echo "")
-$([ -f docs/REQUIREMENTS.md ] && echo "=== REQUIREMENTS ===" && cat docs/REQUIREMENTS.md && echo "")
-$([ -f docs/CLAUDE-NOTES.md ] && echo "=== TECHNICAL NOTES ===" && cat docs/CLAUDE-NOTES.md && echo "")
-$([ -f README.md ] && echo "=== README ===" && cat README.md && echo "")
-
-IMPORTANT: Before starting ANY work, you MUST read and understand:
-1. The project's CLAUDE.md file (if it exists) - this contains project-specific instructions
-2. The user's global CLAUDE.md file at ~/.claude/CLAUDE.md (if it exists) - this contains general development principles
-3. Ensure all your work follows the architectural and development guidelines from both files
-
-CRITICAL ANTI-PATTERNS TO AVOID (from CLAUDE.md):
-- NO CHEATING: Never disable tests, exclude files from compilation, or use silent fallbacks
-- FAIL FAST: Integration failures should throw exceptions, not return mock data
-- NO PRODUCTION FALLBACKS: Avoid try/catch blocks that hide errors with default values
-- NO BACKUP COPIES: Use git for version control, never create backup files
-- DELETE OLD CODE: Remove unused functions and scripts, keep the codebase clean
-
-YOUR MISSION:
-1. Analyze the full project plan and identify all tasks that need to be completed
-2. Group related tasks that can be done in parallel by different agents
-3. Launch multiple Task agents concurrently to maximize efficiency
-4. Each agent should have a clear, specific brief about what to implement
-5. Coordinate the work to ensure consistency across all agents
-
-EXECUTION STRATEGY:
-- Read all project documentation first to understand the full scope
-- Create a mental map of dependencies between tasks
-- Launch agents for independent tasks in parallel batches
-- For dependent tasks, sequence them appropriately
-- Each agent should be given enough context to work autonomously
-
-TASK AGENT GUIDELINES FOR BRIEFS:
-When creating prompts for Task agents, ensure each one:
-- Has a clear, specific goal
-- Understands the project architecture and conventions
-- Knows about related components they might need to integrate with
-- Follows all CLAUDE.md guidelines
-- Includes relevant code style and testing requirements
-
-VERIFICATION:
-After all agents complete:
-- Review what was accomplished vs the plan
-- Run any tests or linters specified in the project
-- Summarize completion status and any issues encountered
-
-Start by analyzing the project and planning your parallel execution strategy.
-Then launch the Task agents to build this project rapidly and efficiently.
-
-Remember: This is a one-shot execution. Make it count!"
-
-echo "Running Claude dev-mini omnibus prompt..."
-echo "This will launch multiple parallel Task agents to complete the project..."
-echo
-
-# Run the omnibus prompt
-claude --dangerously-skip-permissions -p "$omnibus_prompt" 2>&1 | tee "$LOGFILE"
-
-echo
-echo -e "\033[32m==================================================================\033[0m"
-echo -e "\033[32m== DEV-MINI EXECUTION COMPLETE\033[0m"
-echo -e "\033[32m==================================================================\033[0m"
-echo
-
-# Run a verifier to check progress
-verifier_prompt="You are a project completion verifier.
-
-Review the work that was just completed and compare it against:
-$([ -f docs/PLAN.md ] && echo "=== ORIGINAL PLAN ===" && cat docs/PLAN.md && echo "")
-
-Your job:
-1. List what was successfully completed
-2. List what remains to be done (if anything)
-3. Estimate the completion percentage
-4. Identify any issues or errors encountered
-5. Recommend next steps:
-   - If mostly complete: suggest minor fixes
-   - If significantly incomplete: recommend switching to 'claudefsd dev' mode
-
-Be honest and thorough in your assessment.
-Format your response clearly with sections for completed tasks, remaining tasks, and recommendations."
-
-echo "Running completion verifier..."
-echo
-
-claude --dangerously-skip-permissions -p "$verifier_prompt" 2>&1 | tee -a "$LOGFILE"
-
-echo
-echo "Full log saved to: $LOGFILE"
-echo
-echo "If the project is incomplete, you can continue with:"
-echo "  claudefsd dev      # For iterative development mode"
-echo
-
-# Clean up
-rm -rf "$tmp_dir"