@wavilikhin/ralph-wiggum 0.1.14 → 0.1.16

package/README.md

@@ -1,7 +1,7 @@
 # Ralph Wiggum
 
 [![npm version](https://img.shields.io/npm/v/@wavilikhin/ralph-wiggum.svg)](https://www.npmjs.com/package/@wavilikhin/ralph-wiggum)
-[![npm publish](https://github.com/wavilikhin/ralph-wiggum/actions/workflows/publish.yml/badge.svg?event=push)](https://github.com/wavilikhin/ralph-wiggum/actions/workflows/publish.yml)
+[![npm publish](https://github.com/wavilikhin/ralph-wiggum/actions/workflows/publish.yml/badge.svg)](https://github.com/wavilikhin/ralph-wiggum/actions/workflows/publish.yml)
 
 ```
   ____       _       _       __        ___                       
@@ -12,171 +12,71 @@
               |_|                          |___/                   
 ```
 
-## Installation
+Ralph Wiggum is a tiny wrapper around the “autonomous loop” pattern: run an AI coding agent repeatedly, but keep each iteration small and strict.
 
-```bash
-# npm
-npx @wavilikhin/ralph-wiggum init
-
-# bun
-bunx @wavilikhin/ralph-wiggum init
-```
-
-Or install globally:
-
-```bash
-# npm
-npm install -g @wavilikhin/ralph-wiggum
-
-# bun
-bun install -g @wavilikhin/ralph-wiggum
-```
-
----
-
-This is a near-vanilla implementation of the [Ralph Wiggum autonomous loop](https://ghuntley.com/ralph/) pattern by Geoffrey Huntley. The core idea: run an AI coding agent in a loop where each iteration gets fresh context, picks exactly one task, implements it, validates it passes all checks, commits, and repeats until done. This produces clean atomic commits and avoids context window bloat.
-
-Built for [OpenCode](https://opencode.ai), but should work with any CLI-based coding agent that can read files and run commands.
-
-**Additions to the original pattern:**
-- `npx` initialization that scaffolds everything into a `.ralph/` directory
-- Structured logging with timestamps (`.ralph/logs/ralph.log`)
-- `--verbose` flag to preserve full agent output per iteration
-- Enforces exactly one commit per iteration (fails if zero or multiple)
-- Verifies clean working tree after each iteration
-- Phases-based `IMPLEMENTATION_PLAN.md` template
-
----
+Origin: the [Ralph Wiggum autonomous loop](https://ghuntley.com/ralph/) pattern by Geoffrey Huntley.
 
-## What is this?
+Each iteration:
+- starts with fresh context (new process)
+- completes exactly one plan item
+- runs your repo’s validation commands
+- creates exactly one local git commit
 
-Ralph Wiggum runs your coding agent in a loop, where each iteration:
+This keeps context focused and your history clean.
 
-1. Starts with **fresh context** (new process, no memory of previous iterations)
-2. Picks **exactly one task** from your implementation plan
-3. Implements it and runs **validation gates** (lint, test, build)
-4. Creates **exactly one commit** (local only, no push)
-5. Repeats until all tasks are complete
+## Install
 
-This approach keeps context focused and produces clean, atomic commits.
-
-## Model Requirements
-
-> **Warning**: Ralph Wiggum requires the latest generation of AI models to work reliably.
-> 
-> The autonomous loop requires models capable of:
-> - Following complex multi-step instructions precisely
-> - Making exactly one commit per iteration
-> - Running validation commands and fixing failures
-> - Updating state files accurately
->
-> **Recommended models:**
-> - `anthropic/claude-opus-4-20250514`
-> - `openai/gpt-5.2`
->
-> Using older or less capable models will likely result in failed iterations.
-
-## Prerequisites
-
-- [OpenCode CLI](https://opencode.ai) installed and configured (or another CLI agent)
-- Node.js 18+
-- Git repository
-- **AGENTS.md file in your repo root** (see below)
+No global install needed:
 
 ```bash
-# Verify opencode is working
-opencode --version
-
-# List available models
-opencode models
+npx @wavilikhin/ralph-wiggum init
 ```
 
-### AGENTS.md Requirement
+(Inside an existing git repo.)
 
-Ralph Wiggum expects your repository to have a well-configured `AGENTS.md` file at the root. This file tells the AI agent how to validate changes in your project.
-
-Your `AGENTS.md` must include:
-
-1. **Validation commands** - How to run formatting, linting, type checking, and tests
-2. **Project structure** - Overview of your codebase layout
-3. **Coding standards** - Any conventions the agent should follow
-
-Example minimal `AGENTS.md`:
-
-```markdown
-## Validation Commands
+## Quick start
 
-Run these commands to validate changes:
-
-1. Format: `npm run format`
-2. Lint: `npm run lint`
-3. Typecheck: `npm run typecheck`
-4. Test: `npm test`
-
-## Project Structure
-
-- `src/` - Source code
-- `tests/` - Test files
-```
-
-See [OpenCode AGENTS.md documentation](https://opencode.ai/docs/agents-md) for best practices.
-
-## Quick Start
+1) Ensure you have prerequisites:
+- Node.js 18+
+- `opencode` installed and configured (or another CLI agent)
+- a repo-root `AGENTS.md` that lists your validation commands
 
-### 1. Initialize in your repo
+2) Scaffold `.ralph/`:
 
 ```bash
-cd your-project
 npx @wavilikhin/ralph-wiggum init
 ```
 
-This creates a `.ralph/` directory with:
-- `PROMPT.md` - Instructions for the AI agent (has mandatory + customizable sections)
-- `IMPLEMENTATION_PLAN.md` - Your task list template
-- `run.sh` - The loop runner
-- `logs/` - Directory for iteration logs
-
-### 2. Fill in your implementation plan
-
-Edit `.ralph/IMPLEMENTATION_PLAN.md` with your tasks:
-
-```markdown
-## Phase 1: Foundation
-
-- [ ] Set up project structure with src/ and tests/ directories
-- [ ] Add TypeScript configuration
-- [ ] Create initial CI pipeline
-
-## Phase 2: Core Implementation
-
-- [ ] Implement user authentication module
-- [ ] Add database connection layer
-- [ ] Create REST API endpoints
-```
-
-Use the checkbox format (`- [ ]` / `- [x]`) - the agent marks tasks complete as it works.
+3) Fill in tasks:
+- Edit `.ralph/IMPLEMENTATION_PLAN.md`
+- Use checkboxes (`- [ ]`, `- [x]`)
 
-### 3. Run the loop
+4) Run the loop:
 
 ```bash
 .ralph/run.sh --max-iterations 20 --model anthropic/claude-opus-4-20250514
 ```
 
-The loop runs until:
-- All tasks are complete (agent outputs `<promise>COMPLETE</promise>`)
-- Max iterations reached
-- You press Ctrl+C
+The loop stops when either:
+- all tasks are checked off and the agent outputs `<promise>COMPLETE</promise>`
+- `--max-iterations` is reached
+- you press Ctrl+C
 
-## CLI Options
+## Flags
+
+`ralph-wiggum init` scaffolds files. The loop itself is controlled via `.ralph/run.sh`.
+
+Any additional flags are forwarded to `opencode run`.
 
 ```bash
 .ralph/run.sh [options]
 
 Options:
-  --max-iterations N    Maximum iterations (default: 50)
+  --max-iterations N    Maximum iterations before stopping (default: 50)
   --model MODEL         Model to use (default: anthropic/claude-opus-4-20250514)
-  --variant NAME        Optional variant name for opencode
-  --verbose             Enable verbose logging (keeps full opencode output)
+  --variant NAME        Optional variant name passed to opencode
+  --verbose             Keep per-iteration logs (.ralph/logs/ralph_iter_N.log)
+  --live                Stream opencode output (requires --verbose)
   --help                Show help
 
 Environment variables:
@@ -184,193 +84,76 @@ Environment variables:
   RALPH_MODEL           Default model
 ```
 
-## Logging
-
-Ralph Wiggum maintains two types of logs in `.ralph/logs/`:
+## What gets created
 
-### Status Log (`.ralph/logs/ralph.log`)
+`init` creates a `.ralph/` directory:
+- `.ralph/PROMPT.md` – instructions the agent reads every iteration
+- `.ralph/IMPLEMENTATION_PLAN.md` – your checklist of tasks
+- `.ralph/run.sh` – the loop runner
+- `.ralph/logs/` – log directory (ignored via `.gitignore`)
 
-Always written. Contains iteration status with timestamps:
+## Logs
 
-```
-[2025-01-19 14:30:15] [ITER] === Iteration 1/20 STARTED ===
-[2025-01-19 14:32:47] [ITER] === Iteration 1 FINISHED: SUCCESS (152s) - feat: add user auth module ===
-[2025-01-19 14:32:48] [ITER] === Iteration 2/20 STARTED ===
-```
+- `.ralph/logs/ralph.log` is always written (timestamps + iteration status).
+- `.ralph/logs/ralph_iter_N.log` is kept only with `--verbose` (or on failures).
 
-Use this to monitor progress:
+Watch progress:
 
 ```bash
-# Watch progress in real-time
 tail -f .ralph/logs/ralph.log
 ```
 
-### Verbose Logs (`.ralph/logs/ralph_iter_N.log`)
+## Safety
 
-Full opencode output per iteration. By default, these are deleted after successful iterations. Use `--verbose` to keep them:
+- Never pushes: commits are local only.
+- Enforces one commit per iteration.
+- Requires a clean working tree after each iteration.
 
-```bash
-.ralph/run.sh --verbose --max-iterations 10
-```
-
-On failure, the iteration log is always preserved for debugging.
-
-## Examples
-
-### Run with Claude Opus 4
-
-```bash
-.ralph/run.sh --max-iterations 10 --model anthropic/claude-opus-4-20250514
-```
-
-### Run with GPT-5.2
-
-```bash
-.ralph/run.sh --max-iterations 10 --model openai/gpt-5.2
-```
-
-### Run with environment variables
-
-```bash
-export RALPH_MODEL="anthropic/claude-opus-4-20250514"
-export RALPH_MAX_ITERATIONS=30
-.ralph/run.sh
-```
-
-### Dry run (single iteration)
-
-```bash
-.ralph/run.sh --max-iterations 1
-```
-
-### Debug mode (verbose + single iteration)
-
-```bash
-.ralph/run.sh --verbose --max-iterations 1
-```
-
-## How It Works
-
-```
-                       .ralph/run.sh
-                            |
-                            v
-        +---------------------------------------+
-        |         Iteration N                   |
-        |  +----------------------------------+ |
-        |  | 1. Record git HEAD              | |
-        |  | 2. Run: opencode run ...        | |
-        |  | 3. Agent reads PROMPT.md        | |
-        |  | 4. Agent picks ONE task         | |
-        |  | 5. Agent implements + validates | |
-        |  | 6. Agent commits (local only)   | |
-        |  | 7. Check: exactly 1 commit?     | |
-        |  | 8. Check: working tree clean?   | |
-        |  | 9. Check: COMPLETE marker?      | |
-        |  +----------------------------------+ |
-        +---------------------------------------+
-                            |
-               +------------+------------+
-               v                         v
-         [COMPLETE]                 [Continue]
-          Exit 0                   Iteration N+1
-```
-
-Each iteration is a fresh `opencode run` process, so the agent:
-- Has no memory of previous iterations
-- Must re-read PROMPT.md, AGENTS.md, IMPLEMENTATION_PLAN.md
-- Stays focused on one task at a time
+<details>
+<summary><strong>AI agent appendix (full detail)</strong></summary>
 
-## File Structure
+### Model requirements
 
-After initialization, your repo will have:
+This loop is strict and works best with high-end models that can follow multistep instructions reliably:
+- `anthropic/claude-opus-4-20250514`
+- `openai/gpt-5.2`
 
-```
-your-project/
-├── .ralph/
-│   ├── PROMPT.md              # Agent instructions (edit [CUSTOMIZABLE] sections)
-│   ├── IMPLEMENTATION_PLAN.md # Your task list (fill this in)
-│   ├── run.sh                 # Loop runner script
-│   └── logs/
-│       ├── ralph.log          # Iteration status log
-│       └── ralph_iter_N.log   # Per-iteration logs (verbose/error only)
-├── AGENTS.md                  # Your validation commands (required, you create this)
-└── .gitignore                 # Updated to ignore .ralph/logs/
-```
+### `AGENTS.md` (repo root) is required
 
-### .ralph/PROMPT.md
+Ralph Wiggum expects a repo-root `AGENTS.md` that tells the agent how to validate changes.
 
-Contains instructions the agent follows each iteration. Has two types of sections:
+At minimum, include:
+- formatting command
+- lint command
+- typecheck command (if applicable)
+- test command
 
-- **[MANDATORY] sections**: Core loop mechanics - don't modify these
-- **[CUSTOMIZABLE] sections**: Add project-specific context, quality standards
-
-### .ralph/IMPLEMENTATION_PLAN.md
-
-Your task list. Structure it in phases:
+Example (minimal):
 
 ```markdown
-## Phase 1: Foundation
-- [ ] Task 1
-- [x] Task 2 (completed)
-
-## Phase 2: Core
-- [ ] Task 3
-
-## Discovered Tasks
-<!-- Agent adds tasks here as it finds them -->
-```
-
-### AGENTS.md (your file, repo root)
-
-Your project's agent configuration. Must exist in repo root before running.
-
-## Safety Features
-
-- **Local only**: Never pushes to remote
-- **One commit per iteration**: Enforced by the loop
-- **Clean working tree**: Verified after each iteration
-- **Max iterations**: Hard stop to prevent runaway loops
-- **Validation gates**: All must pass before commit
-
-## Troubleshooting
-
-### "opencode CLI not found"
-
-Install OpenCode:
-```bash
-npm install -g opencode
+## Validation Commands
+1. Format: `npm run format`
+2. Lint: `npm run lint`
+3. Typecheck: `npm run typecheck`
+4. Test: `npm test`
 ```
 
-### "AGENTS.md not found"
-
-Create an `AGENTS.md` file in your repo root with validation commands. See the [AGENTS.md Requirement](#agentsmd-requirement) section.
-
-### "No commit was created"
-
-The agent must create exactly one commit per iteration. Check `.ralph/logs/ralph_iter_N.log` to see what happened. Common causes:
-- Validation gates failed
-- Agent got stuck on a complex task
-- Task was already complete
-- Model not capable enough (try a more advanced model)
-
-### "Working tree is not clean"
+OpenCode docs: https://opencode.ai/docs/agents-md
 
-The agent left uncommitted changes. This usually means validation failed. Check the log and fix manually, then restart.
+### What happens each iteration
 
-### Loop never completes
+- A fresh `opencode run` process starts (no memory).
+- The agent reads (at least) `.ralph/PROMPT.md`, `.ralph/IMPLEMENTATION_PLAN.md`, and `AGENTS.md`.
+- The agent must pick exactly one unchecked task, implement it, run all validation gates, update the plan, and make exactly one commit.
+- When every task is complete, the agent must output exactly `<promise>COMPLETE</promise>`.
 
-- Check if tasks in `.ralph/IMPLEMENTATION_PLAN.md` are achievable
-- Ensure validation commands in AGENTS.md are correct
-- Try running with `--verbose --max-iterations 1` to debug a single iteration
-- Consider using a more capable model
+### Templates
 
-### Iterations failing consistently
+Scaffolded from:
+- `templates/PROMPT.md`
+- `templates/IMPLEMENTATION_PLAN.md`
 
-This often indicates the model isn't capable enough for autonomous operation. Try:
-- Using `anthropic/claude-opus-4-20250514` or `openai/gpt-5.2`
-- Simplifying tasks in IMPLEMENTATION_PLAN.md
-- Adding more context to AGENTS.md
+</details>
 
 ## Credits
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavilikhin/ralph-wiggum",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Autonomous coding loop for OpenCode - one task, one commit, fresh context per iteration",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -74,10 +74,11 @@ ${YELLOW}Available loop options:${RESET}
   --max-iterations N    Maximum iterations before stopping (default: 50)
   --model provider/m    Model to use (default: anthropic/claude-opus-4-20250514)
   --variant name        Optional variant name passed to opencode
-  --verbose             Enable verbose logging (full opencode output)
+  --verbose             Save per-iteration logs (.ralph/logs/ralph_iter_N.log)
+  --live                Stream opencode output to terminal (requires --verbose)
 
-${DIM}Logs are written to ${CYAN}.ralph/logs/ralph.log${RESET}${DIM} (iteration status)${RESET}
-${DIM}Verbose logs: ${CYAN}.ralph/logs/ralph_iter_N.log${RESET}${DIM} (full output per iteration)${RESET}
+${DIM}Logs are written to ${CYAN}.ralph/logs/ralph.log${RESET}${DIM} (iteration status + timings)${RESET}
+${DIM}Verbose logs: ${CYAN}.ralph/logs/ralph_iter_N.log${RESET}${DIM} (full output per iteration, --verbose only)${RESET}
 
 ${DIM}The loop stops automatically when all tasks are complete (<promise>COMPLETE</promise>)${RESET}
 `);

package/templates/ralph-loop.sh

@@ -17,6 +17,8 @@ MAX_ITERATIONS="${RALPH_MAX_ITERATIONS:-50}"
 MODEL="${RALPH_MODEL:-anthropic/claude-opus-4-20250514}"
 VARIANT=""
 VERBOSE=false
+LIVE=false
+OPENCODE_ARGS=()
 
 # All ralph files are in .ralph/
 RALPH_DIR="$SCRIPT_DIR"
@@ -83,8 +85,11 @@ log_iteration_end() {
     local iter="$1"
     local status="$2"
     local commit_msg="$3"
-    local duration="$4"
-    log_to_file "ITER" "=== Iteration $iter FINISHED: $status (${duration}s) - $commit_msg ==="
+    local iter_duration="$4"
+    local opencode_duration="$5"
+    log_to_file "ITER" "=== Iteration $iter FINISHED: $status (iter=${iter_duration}s, opencode=${opencode_duration}s) - $commit_msg ==="
+    echo ""
+    echo -e "${DIM}Timing: opencode=${opencode_duration}s, iteration=${iter_duration}s${NC}"
 }
 
 #=============================================================================
@@ -111,7 +116,8 @@ print_usage() {
     echo "  --max-iterations N    Maximum iterations (default: $MAX_ITERATIONS)"
     echo "  --model MODEL         Model to use (default: $MODEL)"
     echo "  --variant NAME        Variant name for opencode"
-    echo "  --verbose             Enable verbose logging (full opencode output)"
+    echo "  --verbose             Save per-iteration logs (.ralph/logs/ralph_iter_N.log)"
+    echo "  --live                Stream opencode output to terminal (requires --verbose)"
     echo "  --help                Show this help"
     echo ""
     echo "Environment variables:"
@@ -119,11 +125,11 @@ print_usage() {
     echo "  RALPH_MODEL           Default model"
     echo ""
     echo "Logs:"
-    echo "  .ralph/logs/ralph.log           Iteration status (always written)"
-    echo "  .ralph/logs/ralph_iter_N.log    Full opencode output (verbose mode or on error)"
+    echo "  .ralph/logs/ralph.log           Iteration status + timings (always written)"
+    echo "  .ralph/logs/ralph_iter_N.log    Full opencode output (--verbose only)"
     echo ""
     echo "Example:"
-    echo "  $0 --max-iterations 10 --model anthropic/claude-opus-4-20250514"
+    echo "  $0 --max-iterations 10 --verbose --live"
 }
 
 check_prerequisites() {
@@ -201,14 +207,27 @@ while [[ $# -gt 0 ]]; do
             VERBOSE=true
             shift
             ;;
+        --live)
+            LIVE=true
+            shift
+            ;;
         --help|-h)
             print_usage
             exit 0
             ;;
+        --)
+            shift
+            OPENCODE_ARGS+=("$@")
+            break
+            ;;
         *)
-            log_error "Unknown option: $1"
-            print_usage
-            exit 1
+            if [[ $# -ge 2 && "$2" != -* ]]; then
+                OPENCODE_ARGS+=("$1" "$2")
+                shift 2
+            else
+                OPENCODE_ARGS+=("$1")
+                shift
+            fi
             ;;
     esac
 done
@@ -223,10 +242,17 @@ log_info "Configuration:"
 echo -e "  ${DIM}Max iterations:${NC} $MAX_ITERATIONS"
 echo -e "  ${DIM}Model:${NC} $MODEL"
 echo -e "  ${DIM}Verbose:${NC} $VERBOSE"
+echo -e "  ${DIM}Live output:${NC} $LIVE"
 echo -e "  ${DIM}Repo root:${NC} $REPO_ROOT"
 [[ -n "$VARIANT" ]] && echo -e "  ${DIM}Variant:${NC} $VARIANT"
 echo ""
 
+# Validate --live requires --verbose
+if [[ "$LIVE" == true && "$VERBOSE" != true ]]; then
+    log_error "--live requires --verbose flag"
+    exit 1
+fi
+
 check_prerequisites
 
 mkdir -p "$LOGS_DIR"
@@ -249,6 +275,7 @@ cd "$REPO_ROOT"
 for i in $(seq 1 "$MAX_ITERATIONS"); do
     ITER_START=$(date +%s)
     ITER_LOG_FILE="$LOGS_DIR/ralph_iter_${i}.log"
+    LIVE_PREFIX="  ${DIM}[LIVE ${i}/${MAX_ITERATIONS}]${NC} "
     
     log_iteration_start "$i" "$MAX_ITERATIONS"
 
@@ -265,28 +292,47 @@ for i in $(seq 1 "$MAX_ITERATIONS"); do
     if [[ -n "$VARIANT" ]]; then
         OPENCODE_CMD+=(--variant "$VARIANT")
     fi
+
+    if [[ ${#OPENCODE_ARGS[@]} -gt 0 ]]; then
+        OPENCODE_CMD+=("${OPENCODE_ARGS[@]}")
+    fi
     
     OPENCODE_CMD+=("Follow the attached PROMPT.md. Use AGENTS.md for validation commands and IMPLEMENTATION_PLAN.md for task selection. Do exactly one task and one commit.")
 
     log_info "Running opencode..."
     
+    OPENCODE_START=$(date +%s)
+    
     set +e
-    if [[ "$VERBOSE" == true ]]; then
-        OUTPUT=$("${OPENCODE_CMD[@]}" 2>&1 | tee "$ITER_LOG_FILE")
+    if [[ "$LIVE" == true ]]; then
+        # Stream to terminal AND write to log file
+        # Prefix each opencode line so it doesn't visually clash with ralph logs.
+        "${OPENCODE_CMD[@]}" 2>&1 | while IFS= read -r line; do printf '%b%s\n' "$LIVE_PREFIX" "$line"; done | tee "$ITER_LOG_FILE"
+        EXIT_CODE=${PIPESTATUS[0]}
+        OUTPUT=$(cat "$ITER_LOG_FILE")
+    elif [[ "$VERBOSE" == true ]]; then
+        # Write to log file only (no terminal stream)
+        "${OPENCODE_CMD[@]}" > "$ITER_LOG_FILE" 2>&1
+        EXIT_CODE=$?
+        OUTPUT=$(cat "$ITER_LOG_FILE")
     else
+        # Capture output, write temp file for error inspection
         OUTPUT=$("${OPENCODE_CMD[@]}" 2>&1)
+        EXIT_CODE=$?
         echo "$OUTPUT" > "$ITER_LOG_FILE"
     fi
-    EXIT_CODE=$?
     set -e
 
+    OPENCODE_END=$(date +%s)
+    OPENCODE_DURATION=$((OPENCODE_END - OPENCODE_START))
+
     ITER_END=$(date +%s)
     ITER_DURATION=$((ITER_END - ITER_START))
 
     if [[ $EXIT_CODE -ne 0 ]]; then
         log_error "opencode exited with code $EXIT_CODE"
         log_error "Check log: $ITER_LOG_FILE"
-        log_iteration_end "$i" "FAILED" "opencode error" "$ITER_DURATION"
+        log_iteration_end "$i" "FAILED" "opencode error" "$ITER_DURATION" "$OPENCODE_DURATION"
         exit 1
     fi
 
@@ -295,7 +341,7 @@ for i in $(seq 1 "$MAX_ITERATIONS"); do
         log_success "All tasks complete!"
         echo ""
         echo -e "${GREEN}${BOLD}Loop finished successfully after $i iteration(s)${NC}"
-        log_iteration_end "$i" "COMPLETE" "all tasks done" "$ITER_DURATION"
+        log_iteration_end "$i" "COMPLETE" "all tasks done" "$ITER_DURATION" "$OPENCODE_DURATION"
         log_to_file "INFO" "=== LOOP COMPLETED SUCCESSFULLY ==="
         exit 0
     fi
@@ -307,14 +353,14 @@ for i in $(seq 1 "$MAX_ITERATIONS"); do
         log_error "No commit was created in this iteration!"
         log_error "The agent must create exactly one commit per iteration."
         log_error "Check log: $ITER_LOG_FILE"
-        log_iteration_end "$i" "FAILED" "no commit created" "$ITER_DURATION"
+        log_iteration_end "$i" "FAILED" "no commit created" "$ITER_DURATION" "$OPENCODE_DURATION"
         exit 1
     fi
 
     COMMIT_COUNT=$(git rev-list --count "$BEFORE_HEAD".."$AFTER_HEAD")
     if [[ "$COMMIT_COUNT" -ne 1 ]]; then
         log_error "Expected 1 commit, but $COMMIT_COUNT were created!"
-        log_iteration_end "$i" "FAILED" "multiple commits" "$ITER_DURATION"
+        log_iteration_end "$i" "FAILED" "multiple commits" "$ITER_DURATION" "$OPENCODE_DURATION"
         exit 1
     fi
 
@@ -322,13 +368,13 @@ for i in $(seq 1 "$MAX_ITERATIONS"); do
         log_error "Working tree is not clean after iteration!"
         echo ""
         git status --short
-        log_iteration_end "$i" "FAILED" "dirty working tree" "$ITER_DURATION"
+        log_iteration_end "$i" "FAILED" "dirty working tree" "$ITER_DURATION" "$OPENCODE_DURATION"
         exit 1
     fi
 
     COMMIT_MSG=$(git log -1 --format='%s')
     log_success "Commit created: $COMMIT_MSG"
-    log_iteration_end "$i" "SUCCESS" "$COMMIT_MSG" "$ITER_DURATION"
+    log_iteration_end "$i" "SUCCESS" "$COMMIT_MSG" "$ITER_DURATION" "$OPENCODE_DURATION"
     
     if [[ "$VERBOSE" != true ]]; then
         rm -f "$ITER_LOG_FILE"