@wavilikhin/ralph-wiggum 0.1.14 → 0.1.15

package/README.md

@@ -1,182 +1,69 @@
 # 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)
 
-```
-  ____       _       _       __        ___                       
- |  _ \ __ _| |_ __ | |__    \ \      / (_) __ _ _   _ _   _ _ __ 
- | |_) / _` | | '_ \| '_ \    \ \ /\ / /| |/ _` | | | | | | | '_ \
- |  _ < (_| | | |_) | | | |    \ V  V / | | (_| | |_| | |_| | | | |
- |_| \_\__,_|_| .__/|_| |_|     \_/\_/  |_|\__, |\__,_|\__,_|_| |_|
-              |_|                          |___/                   
-```
+Ralph Wiggum is a tiny wrapper around the “autonomous loop” pattern: run an AI coding agent repeatedly, but keep each iteration small and strict.
 
-## Installation
+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
 
-```bash
-# npm
-npx @wavilikhin/ralph-wiggum init
+This keeps context focused and your history clean.
 
-# bun
-bunx @wavilikhin/ralph-wiggum init
-```
+## Install
 
-Or install globally:
+No global install needed:
 
 ```bash
-# npm
-npm install -g @wavilikhin/ralph-wiggum
-
-# bun
-bun install -g @wavilikhin/ralph-wiggum
+npx @wavilikhin/ralph-wiggum init
 ```
 
----
-
-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
-
----
-
-## What is this?
-
-Ralph Wiggum runs your coding agent in a loop, where each iteration:
-
-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
+(Inside an existing git repo.)
 
-This approach keeps context focused and produces clean, atomic commits.
+## Quick start
 
-## 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)
+1) Ensure you have prerequisites:
 - Node.js 18+
-- Git repository
-- **AGENTS.md file in your repo root** (see below)
-
-```bash
-# Verify opencode is working
-opencode --version
-
-# List available models
-opencode models
-```
+- `opencode` installed and configured (or another CLI agent)
+- a repo-root `AGENTS.md` that lists your validation commands
 
-### AGENTS.md Requirement
-
-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
-
-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. 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
+3) Fill in tasks:
+- Edit `.ralph/IMPLEMENTATION_PLAN.md`
+- Use checkboxes (`- [ ]`, `- [x]`)
 
-### 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. 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
+
+## Flags
 
-## CLI Options
+`ralph-wiggum init` scaffolds files. The loop itself is controlled via `.ralph/run.sh`:
 
 ```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 +71,76 @@ Environment variables:
   RALPH_MODEL           Default model
 ```
 
-## Logging
+## What gets created
 
-Ralph Wiggum maintains two types of logs in `.ralph/logs/`:
+`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`)
 
-### Status Log (`.ralph/logs/ralph.log`)
+## Logs
 
-Always written. Contains iteration status with timestamps:
-
-```
-[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
-```
+<details>
+<summary><strong>AI agent appendix (full detail)</strong></summary>
 
-### Run with GPT-5.2
+### Model requirements
 
-```bash
-.ralph/run.sh --max-iterations 10 --model openai/gpt-5.2
-```
+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`
 
-### Run with environment variables
+### `AGENTS.md` (repo root) is required
 
-```bash
-export RALPH_MODEL="anthropic/claude-opus-4-20250514"
-export RALPH_MAX_ITERATIONS=30
-.ralph/run.sh
-```
+Ralph Wiggum expects a repo-root `AGENTS.md` that tells the agent how to validate changes.
 
-### Dry run (single iteration)
+At minimum, include:
+- formatting command
+- lint command
+- typecheck command (if applicable)
+- test command
 
-```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
-
-## File Structure
-
-After initialization, your repo will have:
-
-```
-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/
-```
-
-### .ralph/PROMPT.md
-
-Contains instructions the agent follows each iteration. Has two types of sections:
-
-- **[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.15",
   "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,7 @@ MAX_ITERATIONS="${RALPH_MAX_ITERATIONS:-50}"
 MODEL="${RALPH_MODEL:-anthropic/claude-opus-4-20250514}"
 VARIANT=""
 VERBOSE=false
+LIVE=false
 
 # All ralph files are in .ralph/
 RALPH_DIR="$SCRIPT_DIR"
@@ -83,8 +84,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 +115,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 +124,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,6 +206,10 @@ while [[ $# -gt 0 ]]; do
             VERBOSE=true
             shift
             ;;
+        --live)
+            LIVE=true
+            shift
+            ;;
         --help|-h)
             print_usage
             exit 0
@@ -223,10 +232,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"
@@ -270,23 +286,37 @@ for i in $(seq 1 "$MAX_ITERATIONS"); do
 
     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
+        "${OPENCODE_CMD[@]}" 2>&1 | 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 +325,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 +337,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 +352,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"