diff --git a/Cargo.lock b/Cargo.lock index 7ec765c..05e1252 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -990,7 +990,7 @@ dependencies = [ "libc", "option-ext", "redox_users 0.5.2", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -1062,7 +1062,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -2333,7 +2333,7 @@ version = "0.50.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" dependencies = [ - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -2904,7 +2904,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys 0.11.0", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -3292,7 +3292,7 @@ dependencies = [ "getrandom 0.3.4", "once_cell", "rustix 1.1.2", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -3935,7 +3935,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.48.0", + "windows-sys 0.61.2", ] [[package]] diff --git a/README.md b/README.md index c3b09aa..c1986ed 100644 --- a/README.md +++ b/README.md @@ -132,6 +132,40 @@ G3 is designed for: ## Getting Started +### Default Mode: Accumulative Autonomous + +The default interactive mode now uses **accumulative autonomous mode**, which combines the best of interactive and autonomous workflows: + +```bash +# Simply run g3 in any directory +g3 + +# You'll be prompted to describe what you want to build +# Each input you provide: +# 1. Gets added to accumulated requirements +# 2. Automatically triggers autonomous mode (coach-player loop) +# 3. Implements your requirements iteratively + +# Example session: +requirement> create a simple web server in Python with Flask +# ... autonomous mode runs and implements it ... +requirement> add a /health endpoint that returns JSON +# ... autonomous mode runs again with both requirements ... +``` + +### Other Modes + +```bash +# Single-shot mode (one task, then exit) +g3 "implement a function to calculate fibonacci numbers" + +# Traditional autonomous mode (reads requirements.md) +g3 --autonomous + +# Traditional chat mode (simple interactive chat without autonomous runs) +g3 --chat +``` + ```bash # Build the project cargo build --release diff --git a/crates/g3-cli/src/lib.rs b/crates/g3-cli/src/lib.rs index 355cffc..56c1cf9 100644 --- a/crates/g3-cli/src/lib.rs +++ b/crates/g3-cli/src/lib.rs @@ -174,7 +174,7 @@ mod machine_ui_writer; use machine_ui_writer::MachineUiWriter; use ui_writer_impl::ConsoleUiWriter; -#[derive(Parser)] +#[derive(Parser, Clone)] #[command(name = "g3")] #[command(about = "A modular, composable AI coding agent")] #[command(version)] @@ -214,9 +214,9 @@ pub struct Cli { #[arg(long, value_name = "TEXT")] pub requirements: Option, - /// Interactive mode: prompt for requirements and save to requirements.md before starting autonomous mode + /// Enable accumulative autonomous mode (default is chat mode) #[arg(long)] - pub interactive_requirements: bool, + pub auto: bool, /// Enable machine-friendly output mode with JSON markers and stats #[arg(long)] @@ -309,112 +309,6 @@ pub async fn run() -> Result<()> { // Create project model let project = if cli.autonomous { - // Handle interactive requirements mode with AI enhancement - if cli.interactive_requirements { - println!("\nšŸ“ Interactive Requirements Mode"); - println!("================================\n"); - println!("Describe what you want to build (can be brief):"); - println!("Press Ctrl+D (Unix) or Ctrl+Z (Windows) when done.\n"); - - use std::io::{self, Read, Write}; - let mut requirements_input = String::new(); - io::stdin().read_to_string(&mut requirements_input)?; - - if requirements_input.trim().is_empty() { - anyhow::bail!("No requirements provided. Exiting."); - } - - println!("\nšŸ¤– Enhancing your requirements with AI...\n"); - - // Create a temporary agent to enhance the requirements - let temp_config = Config::load_with_overrides( - cli.config.as_deref(), - cli.provider.clone(), - cli.model.clone(), - )?; - - let ui_writer = ConsoleUiWriter::new(); - let mut temp_agent = Agent::new_with_readme_and_quiet( - temp_config, - ui_writer, - None, - true, // quiet mode - ).await?; - - // Craft the enhancement prompt - let enhancement_prompt = format!( - r#"You are a requirements analyst. Take this brief user input and expand it into a structured requirements document. - -USER INPUT: -{} - -Create a professional requirements document with: -1. A clear project title (# heading) -2. An overview section explaining what will be built -3. Organized requirements (functional, technical, quality) -4. Acceptance criteria -5. Any technical constraints or preferences mentioned - -Format as proper markdown. Be specific and actionable. If the user's input is vague, make reasonable assumptions but keep it focused on what they described. - -Output ONLY the markdown content, no explanations or meta-commentary."#, - requirements_input.trim() - ); - - // Execute enhancement task - let result = temp_agent - .execute_task_with_timing(&enhancement_prompt, None, false, false, false, false) - .await?; - - let enhanced_requirements = result.response.trim().to_string(); - - // Show the enhanced requirements - println!("\nšŸ“‹ Enhanced Requirements Document:"); - println!("{}\n", "=".repeat(60)); - println!("{}", enhanced_requirements); - println!("{}\n", "=".repeat(60)); - - // Ask for confirmation - println!("\nā“ Is this requirements document acceptable?"); - println!(" [y] Yes, proceed with autonomous mode"); - println!(" [e] Edit and save manually"); - println!(" [n] No, cancel\n"); - - print!("Your choice (y/e/n): "); - io::stdout().flush()?; - - let mut choice = String::new(); - io::stdin().read_line(&mut choice)?; - let choice = choice.trim().to_lowercase(); - - let requirements_path = workspace_dir.join("requirements.md"); - - match choice.as_str() { - "y" | "yes" => { - // Save enhanced requirements - std::fs::write(&requirements_path, &enhanced_requirements)?; - println!("\nāœ… Requirements saved to: {}", requirements_path.display()); - println!("šŸš€ Starting autonomous mode...\n"); - } - "e" | "edit" => { - // Save enhanced requirements for manual editing - std::fs::write(&requirements_path, &enhanced_requirements)?; - println!("\nāœ… Requirements saved to: {}", requirements_path.display()); - println!("šŸ“ Please edit the file and run: g3 --autonomous"); - println!(" Exiting for now.\n"); - return Ok(()); - } - "n" | "no" => { - println!("\nāŒ Cancelled. No files were saved.\n"); - return Ok(()); - } - _ => { - println!("\nāŒ Invalid choice. Cancelled.\n"); - return Ok(()); - } - } - } - if let Some(requirements_text) = &cli.requirements { // Use requirements text override Project::new_autonomous_with_requirements(workspace_dir.clone(), requirements_text.clone())? @@ -482,6 +376,7 @@ Output ONLY the markdown content, no explanations or meta-commentary."#, // Execute task, autonomous mode, or start interactive mode based on machine mode if cli.machine { // Machine mode - use MachineUiWriter + let ui_writer = MachineUiWriter::new(); let agent = if cli.autonomous { @@ -505,6 +400,20 @@ Output ONLY the markdown content, no explanations or meta-commentary."#, run_with_machine_mode(agent, cli, project).await?; } else { // Normal mode - use ConsoleUiWriter + + // DEFAULT: Chat mode for interactive sessions + // It runs when: + // 1. No task is provided (not single-shot) + // 2. Not in autonomous mode + // 3. Not explicitly enabled with --auto flag + let use_accumulative = cli.task.is_none() && !cli.autonomous && cli.auto; + + if use_accumulative { + // Run accumulative mode and return early + run_accumulative_mode(workspace_dir.clone(), cli.clone(), combined_content.clone()).await?; + return Ok(()); + } + let ui_writer = ConsoleUiWriter::new(); let agent = if cli.autonomous { @@ -527,7 +436,274 @@ Output ONLY the markdown content, no explanations or meta-commentary."#, run_with_console_mode(agent, cli, project, combined_content).await?; } + + Ok(()) +} +/// Accumulative autonomous mode: accumulates requirements from user input +/// and runs autonomous mode after each input +async fn run_accumulative_mode( + workspace_dir: PathBuf, + cli: Cli, + combined_content: Option, +) -> Result<()> { + let output = SimpleOutput::new(); + + output.print(""); + output.print("šŸŖæ G3 AI Coding Agent - Autonomous Mode"); + output.print(" >> describe what you want, I'll build it iteratively"); + output.print(""); + output.print(&format!("šŸ“ Workspace: {}", workspace_dir.display())); + output.print(""); + output.print("šŸ’” Each input you provide will be added to requirements"); + output.print(" and I'll automatically work on implementing them. You can"); + output.print(" interrupt at any time (Ctrl+C) to add clarifications or more requirements."); + output.print(""); + output.print(" Type '/help' for commands, 'exit' or 'quit' to stop, Ctrl+D to finish"); + output.print(""); + + // Initialize rustyline editor with history + let mut rl = DefaultEditor::new()?; + let history_file = dirs::home_dir().map(|mut path| { + path.push(".g3_accumulative_history"); + path + }); + + if let Some(ref history_path) = history_file { + let _ = rl.load_history(history_path); + } + + // Accumulated requirements stored in memory + let mut accumulated_requirements = Vec::new(); + let mut turn_number = 0; + + loop { + output.print(&format!("\n{}", "=".repeat(60))); + if accumulated_requirements.is_empty() { + output.print("šŸ“ What would you like me to build? (describe your requirements)"); + } else { + output.print(&format!("šŸ“ Turn {} - What's next? (add more requirements or refinements)", turn_number + 1)); + } + output.print(&format!("{}", "=".repeat(60))); + + let readline = rl.readline("requirement> "); + match readline { + Ok(line) => { + let input = line.trim().to_string(); + + if input.is_empty() { + continue; + } + + if input == "exit" || input == "quit" { + output.print("\nšŸ‘‹ Goodbye!"); + break; + } + + // Check for slash commands + if input.starts_with('/') { + match input.as_str() { + "/help" => { + output.print(""); + output.print("šŸ“– Available Commands:"); + output.print(" /requirements - Show all accumulated requirements"); + output.print(" /chat - Switch to interactive chat mode"); + output.print(" /help - Show this help message"); + output.print(" exit/quit - Exit the session"); + output.print(""); + continue; + } + "/requirements" => { + output.print(""); + if accumulated_requirements.is_empty() { + output.print("šŸ“‹ No requirements accumulated yet"); + } else { + output.print("šŸ“‹ Accumulated Requirements:"); + output.print(""); + for req in &accumulated_requirements { + output.print(&format!(" {}", req)); + } + } + output.print(""); + continue; + } + "/chat" => { + output.print(""); + output.print("šŸ”„ Switching to interactive chat mode..."); + output.print(""); + + // Build context message with accumulated requirements + let requirements_context = if accumulated_requirements.is_empty() { + None + } else { + Some(format!( + "šŸ“‹ Context from Accumulative Mode:\n\n\ + We were working on these requirements. There may be unstaged or in-progress changes or recent changes to this branch. This is for your information.\n\n\ + Requirements:\n{}\n", + accumulated_requirements.join("\n") + )) + }; + + // Combine with existing content (README/AGENTS.md) + let chat_combined_content = match (requirements_context, combined_content.clone()) { + (Some(req_ctx), Some(existing)) => Some(format!("{}\n\n{}", req_ctx, existing)), + (Some(req_ctx), None) => Some(req_ctx), + (None, existing) => existing, + }; + + // Load configuration + let mut config = Config::load_with_overrides( + cli.config.as_deref(), + cli.provider.clone(), + cli.model.clone(), + )?; + + // Apply macax flag override + if cli.macax { + config.macax.enabled = true; + } + + // Apply webdriver flag override + if cli.webdriver { + config.webdriver.enabled = true; + } + + // Create agent for interactive mode with requirements context + let ui_writer = ConsoleUiWriter::new(); + let agent = Agent::new_with_readme_and_quiet( + config, + ui_writer, + chat_combined_content.clone(), + cli.quiet, + ) + .await?; + + // Run interactive mode + run_interactive(agent, cli.show_prompt, cli.show_code, chat_combined_content).await?; + + // After returning from interactive mode, exit + output.print("\nšŸ‘‹ Goodbye!"); + break; + } + _ => { + output.print(&format!("āŒ Unknown command: {}. Type /help for available commands.", input)); + continue; + } + } + } + + // Add to history + rl.add_history_entry(&input)?; + + // Add this requirement to accumulated list + turn_number += 1; + accumulated_requirements.push(format!("{}. {}", turn_number, input)); + + // Build the complete requirements document + let requirements_doc = format!( + "# Project Requirements\n\n\ + ## Current Instructions and Requirements:\n\n\ + {}\n\n\ + ## Latest Requirement (Turn {}):\n\n\ + {}", + accumulated_requirements.join("\n"), + turn_number, + input + ); + + output.print(""); + output.print(&format!("šŸ“‹ Current instructions and requirements (Turn {}):", turn_number)); + output.print(&format!(" {}", input)); + output.print(""); + output.print("šŸš€ Starting autonomous implementation..."); + output.print(""); + + // Create a project with the accumulated requirements + let project = Project::new_autonomous_with_requirements( + workspace_dir.clone(), + requirements_doc.clone() + )?; + + // Ensure workspace exists and enter it + project.ensure_workspace_exists()?; + project.enter_workspace()?; + + // Load configuration with CLI overrides + let mut config = Config::load_with_overrides( + cli.config.as_deref(), + cli.provider.clone(), + cli.model.clone(), + )?; + + // Apply macax flag override + if cli.macax { + config.macax.enabled = true; + } + + // Apply webdriver flag override + if cli.webdriver { + config.webdriver.enabled = true; + } + + // Create agent for this autonomous run + let ui_writer = ConsoleUiWriter::new(); + let agent = Agent::new_autonomous_with_readme_and_quiet( + config.clone(), + ui_writer, + combined_content.clone(), + cli.quiet, + ) + .await?; + + // Run autonomous mode with the accumulated requirements + let autonomous_result = tokio::select! { + result = run_autonomous( + agent, + project, + cli.show_prompt, + cli.show_code, + cli.max_turns, + cli.quiet, + ) => result, + _ = tokio::signal::ctrl_c() => { + output.print("\nāš ļø Autonomous run cancelled by user (Ctrl+C)"); + Ok(()) + } + }; + + match autonomous_result + { + Ok(_) => { + output.print(""); + output.print("āœ… Autonomous run completed"); + } + Err(e) => { + output.print(""); + output.print(&format!("āŒ Autonomous run failed: {}", e)); + output.print(" You can provide more requirements to continue."); + } + } + } + Err(ReadlineError::Interrupted) => { + output.print("\nšŸ‘‹ Interrupted. Goodbye!"); + break; + } + Err(ReadlineError::Eof) => { + output.print("\nšŸ‘‹ Goodbye!"); + break; + } + Err(err) => { + error!("Error: {:?}", err); + break; + } + } + } + + // Save history before exiting + if let Some(ref history_path) = history_file { + let _ = rl.save_history(history_path); + } + Ok(()) } diff --git a/docs/ACCUMULATIVE_MODE.md b/docs/ACCUMULATIVE_MODE.md new file mode 100644 index 0000000..c2767c7 --- /dev/null +++ b/docs/ACCUMULATIVE_MODE.md @@ -0,0 +1,389 @@ +# Accumulative Autonomous Mode + +## Overview + +Accumulative Autonomous Mode is the **new default interactive mode** for G3. It combines the ease of interactive chat with the power of autonomous implementation, allowing you to build projects iteratively by describing what you want, one requirement at a time. + +## How It Works + +### The Flow + +1. **Start G3** in any directory (no arguments needed) +2. **Describe** what you want to build +3. **G3 automatically**: + - Adds your input to accumulated requirements + - Runs autonomous mode (coach-player feedback loop) + - Implements your requirements with quality checks +4. **Continue** adding more requirements or refinements +5. **Repeat** until your project is complete + +### Example Session + +```bash +$ cd ~/projects/my-new-app +$ g3 + +šŸŖæ G3 AI Coding Agent - Accumulative Mode + >> describe what you want, I'll build it iteratively + +šŸ“ Workspace: /Users/you/projects/my-new-app + +šŸ’” Each input you provide will be added to requirements + and I'll automatically work on implementing them. + + Type 'exit' or 'quit' to stop, Ctrl+D to finish + +============================================================ +šŸ“ What would you like me to build? (describe your requirements) +============================================================ +requirement> create a simple web server in Python with Flask that serves a homepage + +šŸ“‹ Current instructions and requirements (Turn 1): + create a simple web server in Python with Flask that serves a homepage + +šŸš€ Starting autonomous implementation... + +šŸ¤– G3 AI Coding Agent - Autonomous Mode +šŸ“ Using workspace: /Users/you/projects/my-new-app +šŸ“‹ Requirements loaded from --requirements flag +šŸ”„ Starting coach-player feedback loop... +šŸ“‚ No existing implementation files detected +šŸŽÆ Starting with player implementation + +=== TURN 1/5 - PLAYER MODE === +šŸŽÆ Starting player implementation... +šŸ“‹ Player starting initial implementation (no prior coach feedback) + +[Player creates files, writes code...] + +=== TURN 1/5 - COACH MODE === +šŸŽ“ Starting coach review... +šŸŽ“ Coach review completed +Coach feedback: +The Flask server is implemented correctly with a homepage route. +The code follows best practices and meets the requirements. +IMPLEMENTATION_APPROVED + +=== SESSION COMPLETED - IMPLEMENTATION APPROVED === +āœ… Coach approved the implementation! + +============================================================ +šŸ“Š AUTONOMOUS MODE SESSION REPORT +============================================================ +ā±ļø Total Duration: 12.34s +šŸ”„ Turns Taken: 1/5 +šŸ“ Final Status: āœ… APPROVED +... +============================================================ + +āœ… Autonomous run completed + +============================================================ +šŸ“ Turn 2 - What's next? (add more requirements or refinements) +============================================================ +requirement> add a /api/users endpoint that returns a list of users as JSON + +šŸ“‹ Current instructions and requirements (Turn 2): + add a /api/users endpoint that returns a list of users as JSON + +šŸš€ Starting autonomous implementation... + +[Autonomous mode runs again with BOTH requirements...] + +============================================================ +šŸ“ Turn 3 - What's next? (add more requirements or refinements) +============================================================ +requirement> exit + +šŸ‘‹ Goodbye! +``` + +## Key Features + +### 1. Requirement Accumulation + +Each input you provide is: +- **Numbered sequentially** (1, 2, 3, ...) +- **Stored in memory** for the session +- **Included in all subsequent runs** + +This means the agent always has the full context of what you've asked for. + +### 2. Automatic Requirements Document + +G3 automatically generates a structured requirements document: + +```markdown +# Project Requirements + +## Current Instructions and Requirements: + +1. create a simple web server in Python with Flask that serves a homepage +2. add a /api/users endpoint that returns a list of users as JSON +3. add error handling for 404 and 500 errors + +## Latest Requirement (Turn 3): + +add error handling for 404 and 500 errors +``` + +This document is passed to autonomous mode, ensuring the agent: +- Knows all previous requirements +- Focuses on the latest addition +- Maintains consistency across iterations + +### 3. Full Autonomous Quality + +Each requirement triggers a complete autonomous run with: +- **Coach-Player Feedback Loop**: Quality assurance built-in +- **Multiple Turns**: Up to 5 iterations per requirement (configurable with `--max-turns`) +- **Compilation Checks**: Ensures code actually works +- **Testing**: Coach can run tests to verify functionality + +### 4. Error Recovery + +If an autonomous run fails: +- You're notified of the error +- You can provide additional requirements to fix issues +- The session continues (doesn't crash) + +### 5. Workspace Management + +- Uses **current directory** as workspace +- All files created in current directory +- No need to specify workspace path +- Works with existing projects or empty directories + +## Command-Line Options + +### Default (Accumulative Mode) + +```bash +g3 +``` + +Starts accumulative autonomous mode in the current directory. + +### With Options + +```bash +# Use a specific workspace +g3 --workspace ~/projects/my-app + +# Limit autonomous turns per requirement +g3 --max-turns 3 + +# Enable macOS Accessibility tools +g3 --macax + +# Enable WebDriver browser automation +g3 --webdriver + +# Use a specific provider/model +g3 --provider anthropic --model claude-3-5-sonnet-20241022 + +# Show prompts and code during execution +g3 --show-prompt --show-code + +# Disable log files +g3 --quiet +``` + +### Disable Accumulative Mode + +To use the traditional chat mode (without automatic autonomous runs): + +```bash +g3 --chat + +# Alternative: legacy flag also works +g3 --accumulative +``` + +This gives you the old behavior where you chat with the agent without automatic autonomous runs. + +## Use Cases + +### 1. Rapid Prototyping + +```bash +requirement> create a REST API for a todo app +requirement> add SQLite database storage +requirement> add authentication with JWT +requirement> add rate limiting +``` + +### 2. Iterative Refinement + +```bash +requirement> create a data visualization dashboard +requirement> make the charts interactive +requirement> add dark mode support +requirement> optimize for mobile devices +``` + +### 3. Bug Fixing + +```bash +requirement> fix the login form validation +requirement> handle edge case when username is empty +requirement> add better error messages +``` + +### 4. Feature Addition + +```bash +requirement> add export to CSV functionality +requirement> add email notifications +requirement> add admin dashboard +``` + +## Tips and Best Practices + +### 1. Start Simple + +Begin with a basic requirement, let it be implemented, then add complexity: + +```bash +āœ… Good: +requirement> create a basic Flask web server +requirement> add a homepage with a form +requirement> add form validation + +āŒ Too Complex: +requirement> create a full-stack web app with authentication, database, API, and frontend +``` + +### 2. Be Specific + +The more specific you are, the better the results: + +```bash +āœ… Good: +requirement> add a /api/users endpoint that returns JSON with id, name, and email fields + +āŒ Vague: +requirement> add users +``` + +### 3. One Thing at a Time + +Focus each requirement on a single feature or fix: + +```bash +āœ… Good: +requirement> add error handling for database connections +requirement> add logging for all API requests + +āŒ Multiple Things: +requirement> add error handling and logging and monitoring and alerts +``` + +### 4. Review Between Turns + +After each autonomous run completes: +- Check the generated files +- Test the functionality +- Decide what to add or fix next + +### 5. Use Exit Commands + +When done: +- Type `exit` or `quit` +- Press `Ctrl+D` (EOF) +- Press `Ctrl+C` to cancel current input + +## Comparison with Other Modes + +| Feature | Accumulative (Default) | Traditional Interactive | Autonomous | Single-Shot | +|---------|----------------------|------------------------|------------|-------------| +| **Command** | `g3` | `g3 --accumulative` | `g3 --autonomous` | `g3 "task"` | +| **Input Style** | Iterative prompts | Chat messages | requirements.md file | Command-line arg | +| **Auto-Autonomous** | āœ… Yes | āŒ No | āœ… Yes | āŒ No | +| **Coach-Player Loop** | āœ… Yes | āŒ No | āœ… Yes | āŒ No | +| **Accumulates Requirements** | āœ… Yes | āŒ No | āŒ No | āŒ No | +| **Multiple Iterations** | āœ… Yes | āœ… Yes | āœ… Yes | āŒ No | +| **Best For** | Iterative development | Quick questions | Pre-planned projects | One-off tasks | + +## Technical Details + +### Requirements Storage + +- Stored in memory (not persisted to disk) +- Numbered sequentially starting from 1 +- Formatted as markdown list +- Passed to autonomous mode as `--requirements` override + +### History + +- Saved to `~/.g3_accumulative_history` +- Separate from traditional interactive history +- Persists across sessions +- Uses rustyline for readline support + +### Workspace + +- Defaults to current directory +- Can be overridden with `--workspace` +- All files created in workspace +- Logs saved to `workspace/logs/` + +### Autonomous Execution + +- Full coach-player feedback loop +- Configurable max turns (default: 5) +- Respects all CLI flags (--macax, --webdriver, etc.) +- Error handling allows continuation + +## Troubleshooting + +### "No requirements provided" + +This shouldn't happen in accumulative mode, but if it does: +- Check that you entered a requirement +- Ensure the requirement isn't empty +- Try restarting G3 + +### "Autonomous run failed" + +If an autonomous run fails: +- Read the error message +- Provide a new requirement to fix the issue +- Or type `exit` and investigate manually + +### "Context window full" + +If you hit token limits: +- The agent will auto-summarize +- Or you can start a new session +- Consider using `--max-turns` to limit iterations + +### "Coach never approves" + +If the coach keeps rejecting: +- Check the coach feedback for specific issues +- Provide more specific requirements +- Consider increasing `--max-turns` + +## Future Enhancements + +Planned improvements: + +1. **Persistence**: Save accumulated requirements to disk +2. **Editing**: Edit or remove previous requirements +3. **Branching**: Try different approaches +4. **Templates**: Pre-defined requirement sets +5. **Review**: Show all accumulated requirements +6. **Export**: Save to requirements.md +7. **Undo**: Remove last requirement +8. **Replay**: Re-run with same requirements + +## Feedback + +This is a new feature! Please provide feedback: +- What works well? +- What's confusing? +- What features would you like? +- Any bugs or issues? + +Open an issue on GitHub or contribute improvements!