ccsetup 1.1.0 → 1.2.0

package/template/hooks/workflow-selector/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Environment variable toggle — exit early if not enabled
+// Enable with: export CCSETUP_WORKFLOW=1
+const enabled = process.env.CCSETUP_WORKFLOW;
+if (!enabled || (enabled !== '1' && enabled.toLowerCase() !== 'true')) {
+  console.log('{}');
+  process.exit(0);
+}
+
+// Simple workflow selector that reads from agent-orchestration.md
+class WorkflowSelector {
+  constructor() {
+    this.workflows = this.loadWorkflows();
+    this.availableAgents = this.getAvailableAgents();
+  }
+
+  loadWorkflows() {
+    const orchestrationPath = path.join(process.cwd(), 'docs', 'agent-orchestration.md');
+    
+    if (!fs.existsSync(orchestrationPath)) {
+      return this.getDefaultWorkflows();
+    }
+
+    try {
+      // First try to use Claude to extract workflows intelligently
+      const workflows = this.loadWorkflowsWithClaude(orchestrationPath);
+      if (workflows && Object.keys(workflows).length > 0) {
+        return workflows;
+      }
+    } catch (error) {
+      // Claude extraction failed, continue with regex
+    }
+
+    // Fallback to regex-based extraction
+    return this.loadWorkflowsWithRegex(orchestrationPath);
+  }
+
+  loadWorkflowsWithClaude(orchestrationPath) {
+    const { execSync } = require('child_process');
+    
+    try {
+      const content = fs.readFileSync(orchestrationPath, 'utf8');
+      
+      const extractPrompt = `
+Extract all workflows from this agent orchestration document.
+
+For each workflow, identify:
+1. The workflow name
+2. The sequence of agents used
+3. The purpose/description
+
+Return ONLY a JSON object with this structure:
+{
+  "workflow_key": {
+    "name": "Workflow Name",
+    "agents": ["agent1", "agent2", "agent3"],
+    "purpose": "Brief description"
+  }
+}
+
+Document content:
+${content}
+
+Extract all workflows and return valid JSON only.
+`;
+
+      const claudeResult = execSync(
+        `claude --print "${extractPrompt.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], maxBuffer: 1024 * 1024 * 10 }
+      );
+
+      // Parse the JSON result
+      const parsed = JSON.parse(claudeResult);
+      
+      // Validate and normalize the workflows
+      const workflows = {};
+      for (const [key, workflow] of Object.entries(parsed)) {
+        if (workflow.name && Array.isArray(workflow.agents) && workflow.agents.length > 0) {
+          // Normalize agent names (remove "agent" suffix, lowercase)
+          const normalizedAgents = workflow.agents.map(agent => 
+            agent.toLowerCase().replace(/\s*agent\s*$/, '').trim()
+          );
+          
+          workflows[key] = {
+            name: workflow.name,
+            agents: normalizedAgents,
+            purpose: workflow.purpose || ''
+          };
+        }
+      }
+      
+      return workflows;
+    } catch (error) {
+      // Claude extraction failed
+      return null;
+    }
+  }
+
+  loadWorkflowsWithRegex(orchestrationPath) {
+    try {
+      const content = fs.readFileSync(orchestrationPath, 'utf8');
+      const workflows = {};
+      
+      // Enhanced regex patterns for better extraction
+      const workflowSections = this.extractWorkflowSections(content);
+      
+      for (const section of workflowSections) {
+        const workflow = this.parseWorkflowSection(section);
+        if (workflow) {
+          const key = workflow.name.toLowerCase().replace(/\s+/g, '_');
+          workflows[key] = workflow;
+        }
+      }
+      
+      // If no workflows found, return defaults
+      return Object.keys(workflows).length > 0 ? workflows : this.getDefaultWorkflows();
+    } catch (error) {
+      return this.getDefaultWorkflows();
+    }
+  }
+
+  extractWorkflowSections(content) {
+    const sections = [];
+    
+    // Split by workflow headers
+    const workflowRegex = /### \d+\.\s+(.+?)\s+Workflow([\s\S]*?)(?=### \d+\.|## |$)/g;
+    let match;
+    
+    while ((match = workflowRegex.exec(content)) !== null) {
+      sections.push({
+        name: match[1].trim(),
+        content: match[2].trim()
+      });
+    }
+    
+    return sections;
+  }
+
+  parseWorkflowSection(section) {
+    const workflow = {
+      name: section.name,
+      agents: []
+    };
+    
+    // Look for the Flow section
+    const flowMatch = section.content.match(/\*\*Flow\*\*:?\s*([\s\S]*?)(?=\*\*|###|$)/);
+    if (!flowMatch) return null;
+    
+    const flowContent = flowMatch[1];
+    
+    // Extract agents from various formats
+    const agents = this.extractAgentsFromFlow(flowContent);
+    
+    if (agents.length > 0) {
+      workflow.agents = agents;
+      return workflow;
+    }
+    
+    return null;
+  }
+
+  extractAgentsFromFlow(flowContent) {
+    const agents = [];
+    const lines = flowContent.split('\n');
+    
+    for (const line of lines) {
+      // Pattern 1: "1. **Agent Name** → Description"
+      let match = line.match(/^\d+\.\s*\*\*([^*→]+?)(?:\s+Agent)?\*\*/);
+      
+      // Pattern 2: "- Agent Name: Description"
+      if (!match) {
+        match = line.match(/^[-•]\s*\*\*([^*:]+?)(?:\s+Agent)?\*\*/);
+      }
+      
+      // Pattern 3: "Agent Name →"
+      if (!match) {
+        match = line.match(/^\s*([A-Za-z\s]+?)\s*(?:Agent\s*)?→/);
+      }
+      
+      if (match) {
+        const agent = match[1].toLowerCase()
+          .replace(/\s*agent\s*$/, '')
+          .trim();
+        
+        if (agent && !agents.includes(agent) && agent.length > 0) {
+          agents.push(agent);
+        }
+      }
+    }
+    
+    return agents;
+  }
+
+  getDefaultWorkflows() {
+    return {
+      feature_development: {
+        name: 'Feature Development',
+        agents: ['researcher', 'planner', 'coder', 'checker']
+      },
+      bug_fix: {
+        name: 'Bug Fix',
+        agents: ['researcher', 'coder', 'checker']
+      },
+      refactoring: {
+        name: 'Refactoring',
+        agents: ['researcher', 'planner', 'coder', 'checker']
+      },
+      api_development: {
+        name: 'API Development',
+        agents: ['planner', 'backend', 'frontend', 'checker']
+      },
+      ui_component: {
+        name: 'UI Component',
+        agents: ['frontend', 'shadcn', 'checker']
+      },
+      blockchain: {
+        name: 'Blockchain Development',
+        agents: ['planner', 'blockchain', 'checker']
+      },
+      qa: {
+        name: 'QA',
+        agents: ['researcher', 'checker', 'coder', 'checker']
+      }
+    };
+  }
+
+  getAvailableAgents() {
+    const agentsDir = path.join(process.cwd(), '.claude', 'agents');
+    
+    if (!fs.existsSync(agentsDir)) {
+      return [];
+    }
+    
+    try {
+      return fs.readdirSync(agentsDir)
+        .filter(file => file.endsWith('.md'))
+        .map(file => file.replace('.md', '').toLowerCase());
+    } catch (error) {
+      return [];
+    }
+  }
+
+  async selectWorkflow(prompt) {
+    const { execSync } = require('child_process');
+    
+    try {
+      // First, let's use Claude to analyze the prompt and understand the task type
+      const analyzePrompt = `
+Analyze this user prompt and determine the most appropriate workflow type.
+User prompt: "${prompt}"
+
+Available workflows:
+${Object.entries(this.workflows).map(([key, workflow]) => 
+  `- ${workflow.name}: uses agents [${workflow.agents.join(', ')}]`
+).join('\n')}
+
+Consider:
+1. What type of task is this? (feature, bug fix, refactoring, API work, UI work, testing, etc.)
+2. What agents would be most helpful?
+3. Match to the most appropriate workflow
+
+Respond with ONLY the workflow key (e.g., 'feature_development', 'bug_fix', etc.)
+`;
+
+      // Use Claude to analyze the prompt
+      const claudeAnalysis = execSync(
+        `claude --print "${analyzePrompt.replace(/"/g, '\\"')}"`,
+        { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }
+      ).trim().toLowerCase().replace(/['"]/g, '');
+
+      // Validate the response is a valid workflow key
+      if (this.workflows[claudeAnalysis]) {
+        return this.workflows[claudeAnalysis];
+      }
+
+      // If Claude's response isn't valid, fall back to enhanced keyword matching
+      return this.enhancedKeywordMatching(prompt);
+      
+    } catch (error) {
+      // If Claude command fails, fall back to enhanced keyword matching
+      console.error('Claude analysis failed, using keyword matching:', error.message);
+      return this.enhancedKeywordMatching(prompt);
+    }
+  }
+
+  enhancedKeywordMatching(prompt) {
+    const promptLower = prompt.toLowerCase();
+    
+    // Score each workflow based on keyword matches
+    const scores = {};
+    
+    // Define keyword weights for each workflow
+    const workflowKeywords = {
+      bug_fix: {
+        keywords: ['fix', 'bug', 'error', 'issue', 'broken', 'crash', 'fail', 'debug', 'problem', 'wrong'],
+        weight: 2
+      },
+      refactoring: {
+        keywords: ['refactor', 'improve', 'optimize', 'clean', 'restructure', 'reorganize', 'simplify', 'enhance'],
+        weight: 2
+      },
+      api_development: {
+        keywords: ['api', 'endpoint', 'rest', 'graphql', 'backend', 'server', 'route', 'request', 'response'],
+        weight: 2
+      },
+      ui_component: {
+        keywords: ['ui', 'component', 'frontend', 'react', 'vue', 'interface', 'button', 'form', 'page', 'view'],
+        weight: 2
+      },
+      qa: {
+        keywords: ['test', 'qa', 'quality', 'testing', 'unit', 'integration', 'e2e', 'coverage', 'assert'],
+        weight: 2
+      },
+      feature_development: {
+        keywords: ['add', 'create', 'implement', 'build', 'develop', 'feature', 'new', 'functionality'],
+        weight: 1
+      },
+      blockchain: {
+        keywords: ['blockchain', 'smart contract', 'web3', 'ethereum', 'solidity', 'defi', 'crypto', 'wallet'],
+        weight: 3
+      }
+    };
+    
+    // Calculate scores for each workflow
+    Object.entries(workflowKeywords).forEach(([workflow, config]) => {
+      scores[workflow] = 0;
+      config.keywords.forEach(keyword => {
+        if (promptLower.includes(keyword)) {
+          scores[workflow] += config.weight;
+        }
+      });
+    });
+    
+    // Find the workflow with the highest score
+    let bestWorkflow = 'feature_development';
+    let highestScore = 0;
+    
+    Object.entries(scores).forEach(([workflow, score]) => {
+      if (score > highestScore && this.workflows[workflow]) {
+        highestScore = score;
+        bestWorkflow = workflow;
+      }
+    });
+    
+    return this.workflows[bestWorkflow] || this.workflows.feature_development || Object.values(this.workflows)[0];
+  }
+
+  filterAgentsByAvailability(agents) {
+    if (this.availableAgents.length === 0) {
+      return agents; // Return all if we can't check
+    }
+    
+    return agents.filter(agent => this.availableAgents.includes(agent));
+  }
+}
+
+// Main execution - reads from stdin as Claude Code provides
+if (require.main === module) {
+  let inputData = '';
+  
+  process.stdin.on('data', (chunk) => {
+    inputData += chunk;
+  });
+  
+  process.stdin.on('end', async () => {
+    try {
+      const input = JSON.parse(inputData);
+      const prompt = input.prompt || '';
+      
+      if (!prompt) {
+        console.log('{}');
+        return;
+      }
+      
+      const selector = new WorkflowSelector();
+      const workflow = await selector.selectWorkflow(prompt);
+      const agents = selector.filterAgentsByAvailability(workflow.agents);
+      
+      // Output suggestion — Claude should ask the user before applying
+      const output = {
+        workflow: workflow.name,
+        agents: agents,
+        message: `[Workflow Suggestion] Based on this prompt, the "${workflow.name}" workflow may be a good fit: ${agents.join(' → ')}. Ask the user if they'd like to follow this workflow or just proceed normally with Claude Code's default behavior.`
+      };
+
+      console.log(JSON.stringify(output));
+    } catch (error) {
+      // Silent fail - just return empty
+      console.log('{}');
+    }
+  });
+}
+
+module.exports = WorkflowSelector;

package/template/scripts/ralph/CLAUDE.md

@@ -0,0 +1,174 @@
+# Ralph Agent Instructions
+
+You are an autonomous coding agent working on a software project. You have access to Claude Code's full toolset including subagents.
+
+## Your Task
+
+1. Read the PRD at `prd.json` (in the same directory as this file)
+2. Read the progress log at `progress.txt` (check Codebase Patterns section first)
+3. Check you're on the correct branch from PRD `branchName`. If not, check it out or create from main.
+4. Pick the **highest priority** user story where `passes: false`
+5. Read the story's `notes` field for file hints and relevant context
+6. Implement that single user story
+7. Run quality checks using the exact commands from `prd.json` → `qualityChecks`
+8. **Spawn a reviewer subagent** to independently verify the implementation (see Verification below)
+9. If reviewer approves: commit ALL changes with message `feat: [Story ID] - [Story Title]`
+10. If reviewer rejects: fix the issues, re-run quality checks, and re-verify
+11. Update the PRD to set `passes: true` and populate `notes` with what was actually done
+12. Update CLAUDE.md files if you discover reusable patterns (see below)
+13. Append your progress to `progress.txt`
+
+---
+
+## Quality Checks — Use Exact Commands
+
+The PRD's `qualityChecks` field contains the exact commands for this project:
+
+```json
+"qualityChecks": {
+  "typecheck": "npm run typecheck",
+  "lint": "npm run lint",
+  "test": "npm test"
+}
+```
+
+Run **every command** listed in `qualityChecks` using the Bash tool. Do not guess commands — use exactly what's in the PRD.
+
+If `qualityChecks` is missing (older PRD format), fall back to detecting commands from `package.json` scripts, `Makefile`, or equivalent config files.
+
+**All checks must pass before proceeding to verification.**
+
+---
+
+## Verification — Spawn a Reviewer Subagent
+
+After implementing a story and passing quality checks, you MUST spawn a **checker subagent** using the Agent tool to independently verify the implementation. The implementing agent (you) should not be the sole judge of its own work.
+
+### How to verify
+
+Use the Agent tool with `subagent_type: "checker"` and a prompt like:
+
+```
+Review the implementation of user story [Story ID]: "[Story Title]"
+
+## Acceptance Criteria to verify:
+[paste the acceptance criteria from the story]
+
+## Quality commands to run:
+[paste from prd.json qualityChecks]
+
+## Instructions:
+1. Run `git diff` to see all changes made in the working tree
+2. For each acceptance criterion, verify it is actually met by the code changes — not just that the code compiles
+3. Run each quality check command and confirm they pass
+4. If any acceptance criterion references UI changes, check that the component renders correctly (use browser tools if available)
+5. Look for: missing edge cases, broken imports, unused variables, incomplete implementations
+
+Report back with:
+- PASS or FAIL for each acceptance criterion (with brief reasoning)
+- Overall verdict: APPROVED or CHANGES_REQUESTED
+- If CHANGES_REQUESTED: specific issues to fix
+```
+
+### Acting on the review
+
+- **APPROVED**: Proceed to commit
+- **CHANGES_REQUESTED**: Fix each issue raised, re-run quality checks, then spawn the reviewer again. Maximum 3 review cycles per story — if still failing after 3, log the issues in progress.txt and move on (do NOT mark `passes: true`)
+
+### Why subagent verification matters
+
+The implementing agent has tunnel vision — it wrote the code and is biased toward thinking it works. A fresh subagent context catches:
+- Acceptance criteria that look met but aren't (e.g., criterion says "default 'pending'" but code defaults to null)
+- Quality regressions in files you didn't intend to change
+- Missing integrations (e.g., new API route exists but nothing calls it)
+
+---
+
+## Browser Testing
+
+For any story with "Verify in browser using dev-browser skill" in its acceptance criteria:
+
+1. Navigate to the relevant page
+2. Verify the UI changes work as expected
+3. Take a screenshot if helpful for the progress log
+
+The reviewer subagent should also check UI stories if browser tools are available. If no browser tools are configured, note in your progress report that manual browser verification is needed.
+
+---
+
+## Progress Report Format
+
+APPEND to progress.txt (never replace, always append):
+```
+## [Date/Time] - [Story ID]
+- What was implemented
+- Files changed
+- Review result: [APPROVED / CHANGES_REQUESTED → fixed → APPROVED]
+- Review cycles: [1-3]
+- **Learnings for future iterations:**
+  - Patterns discovered (e.g., "this codebase uses X for Y")
+  - Gotchas encountered (e.g., "don't forget to update Z when changing W")
+  - Useful context (e.g., "the evaluation panel is in component X")
+  - Reviewer catches (e.g., "reviewer caught missing default value on status column")
+---
+```
+
+The learnings section is critical — it helps future iterations avoid repeating mistakes. **Include what the reviewer caught** so future iterations avoid the same issues.
+
+## Consolidate Patterns
+
+If you discover a **reusable pattern** that future iterations should know, add it to the `## Codebase Patterns` section at the TOP of progress.txt (create it if it doesn't exist). This section should consolidate the most important learnings:
+
+```
+## Codebase Patterns
+- Example: Use `sql<number>` template for aggregations
+- Example: Always use `IF NOT EXISTS` for migrations
+- Example: Export types from actions.ts for UI components
+```
+
+Only add patterns that are **general and reusable**, not story-specific details.
+
+## Update CLAUDE.md Files
+
+Before committing, check if any edited files have learnings worth preserving in nearby CLAUDE.md files:
+
+1. **Identify directories with edited files** — Look at which directories you modified
+2. **Check for existing CLAUDE.md** — Look for CLAUDE.md in those directories or parent directories
+3. **Add valuable learnings** — If you discovered something future developers/agents should know:
+   - API patterns or conventions specific to that module
+   - Gotchas or non-obvious requirements
+   - Dependencies between files
+   - Testing approaches for that area
+   - Configuration or environment requirements
+
+**Examples of good CLAUDE.md additions:**
+- "When modifying X, also update Y to keep them in sync"
+- "This module uses pattern Z for all API calls"
+- "Tests require the dev server running on PORT 3000"
+- "Field names must match the template exactly"
+
+**Do NOT add:**
+- Story-specific implementation details
+- Temporary debugging notes
+- Information already in progress.txt
+
+Only update CLAUDE.md if you have **genuinely reusable knowledge** that would help future work in that directory.
+
+---
+
+## Stop Condition
+
+After completing a user story, check if ALL stories have `passes: true`.
+
+If ALL stories are complete and passing, reply with:
+<promise>COMPLETE</promise>
+
+If there are still stories with `passes: false`, end your response normally (another iteration will pick up the next story).
+
+## Important
+
+- Work on ONE story per iteration
+- Commit only after reviewer APPROVES
+- Keep CI green — use the exact commands from `qualityChecks`
+- Read the Codebase Patterns section in progress.txt before starting
+- Read story `notes` for file hints before implementing

package/template/scripts/ralph/ralph.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# Ralph Wiggum - Long-running AI agent loop
+# Usage: ./ralph.sh [--tool amp|claude] [--model opus|sonnet|haiku] [max_iterations]
+
+set -e
+
+# Parse arguments
+TOOL="amp"  # Default to amp for backwards compatibility
+MODEL=""    # Model for claude (opus, sonnet, haiku)
+MAX_ITERATIONS=10
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --tool)
+      TOOL="$2"
+      shift 2
+      ;;
+    --tool=*)
+      TOOL="${1#*=}"
+      shift
+      ;;
+    --model)
+      MODEL="$2"
+      shift 2
+      ;;
+    --model=*)
+      MODEL="${1#*=}"
+      shift
+      ;;
+    *)
+      # Assume it's max_iterations if it's a number
+      if [[ "$1" =~ ^[0-9]+$ ]]; then
+        MAX_ITERATIONS="$1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+# Validate tool choice
+if [[ "$TOOL" != "amp" && "$TOOL" != "claude" ]]; then
+  echo "Error: Invalid tool '$TOOL'. Must be 'amp' or 'claude'."
+  exit 1
+fi
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PRD_FILE="$SCRIPT_DIR/prd.json"
+PROGRESS_FILE="$SCRIPT_DIR/progress.txt"
+ARCHIVE_DIR="$SCRIPT_DIR/archive"
+LAST_BRANCH_FILE="$SCRIPT_DIR/.last-branch"
+
+# Archive previous run if branch changed
+if [ -f "$PRD_FILE" ] && [ -f "$LAST_BRANCH_FILE" ]; then
+  CURRENT_BRANCH=$(jq -r '.branchName // empty' "$PRD_FILE" 2>/dev/null || echo "")
+  LAST_BRANCH=$(cat "$LAST_BRANCH_FILE" 2>/dev/null || echo "")
+  
+  if [ -n "$CURRENT_BRANCH" ] && [ -n "$LAST_BRANCH" ] && [ "$CURRENT_BRANCH" != "$LAST_BRANCH" ]; then
+    # Archive the previous run
+    DATE=$(date +%Y-%m-%d)
+    # Strip "ralph/" prefix from branch name for folder
+    FOLDER_NAME=$(echo "$LAST_BRANCH" | sed 's|^ralph/||')
+    ARCHIVE_FOLDER="$ARCHIVE_DIR/$DATE-$FOLDER_NAME"
+    
+    echo "Archiving previous run: $LAST_BRANCH"
+    mkdir -p "$ARCHIVE_FOLDER"
+    [ -f "$PRD_FILE" ] && cp "$PRD_FILE" "$ARCHIVE_FOLDER/"
+    [ -f "$PROGRESS_FILE" ] && cp "$PROGRESS_FILE" "$ARCHIVE_FOLDER/"
+    echo "   Archived to: $ARCHIVE_FOLDER"
+    
+    # Reset progress file for new run
+    echo "# Ralph Progress Log" > "$PROGRESS_FILE"
+    echo "Started: $(date)" >> "$PROGRESS_FILE"
+    echo "---" >> "$PROGRESS_FILE"
+  fi
+fi
+
+# Track current branch
+if [ -f "$PRD_FILE" ]; then
+  CURRENT_BRANCH=$(jq -r '.branchName // empty' "$PRD_FILE" 2>/dev/null || echo "")
+  if [ -n "$CURRENT_BRANCH" ]; then
+    echo "$CURRENT_BRANCH" > "$LAST_BRANCH_FILE"
+  fi
+fi
+
+# Initialize progress file if it doesn't exist
+if [ ! -f "$PROGRESS_FILE" ]; then
+  echo "# Ralph Progress Log" > "$PROGRESS_FILE"
+  echo "Started: $(date)" >> "$PROGRESS_FILE"
+  echo "---" >> "$PROGRESS_FILE"
+fi
+
+MODEL_DISPLAY="${MODEL:-default}"
+echo "Starting Ralph - Tool: $TOOL - Model: $MODEL_DISPLAY - Max iterations: $MAX_ITERATIONS"
+
+for i in $(seq 1 $MAX_ITERATIONS); do
+  echo ""
+  echo "==============================================================="
+  echo "  Ralph Iteration $i of $MAX_ITERATIONS ($TOOL${MODEL:+ - $MODEL})"
+  echo "==============================================================="
+
+  # Run the selected tool with the ralph prompt
+  if [[ "$TOOL" == "amp" ]]; then
+    OUTPUT=$(cat "$SCRIPT_DIR/prompt.md" | amp --dangerously-allow-all 2>&1 | tee /dev/stderr) || true
+  else
+    # Claude Code: use --dangerously-skip-permissions for autonomous operation, --print for output
+    MODEL_FLAG=""
+    if [[ -n "$MODEL" ]]; then
+      MODEL_FLAG="--model $MODEL"
+    fi
+    OUTPUT=$(claude $MODEL_FLAG --dangerously-skip-permissions --chrome --print < "$SCRIPT_DIR/CLAUDE.md" 2>&1 | tee /dev/stderr) || true
+  fi
+  
+  # Check for completion signal
+  if echo "$OUTPUT" | grep -q "<promise>COMPLETE</promise>"; then
+    echo ""
+    echo "Ralph completed all tasks!"
+    echo "Completed at iteration $i of $MAX_ITERATIONS"
+    exit 0
+  fi
+  
+  echo "Iteration $i complete. Continuing..."
+  sleep 2
+done
+
+echo ""
+echo "Ralph reached max iterations ($MAX_ITERATIONS) without completing all tasks."
+echo "Check $PROGRESS_FILE for status."
+exit 1