golem-cc 0.1.15 → 0.1.17

package/bin/golem

@@ -14,6 +14,12 @@
 #
 set -euo pipefail
 
+# Exit codes for scripting
+readonly EXIT_COMPLETE=0
+readonly EXIT_INCOMPLETE=1
+readonly EXIT_NO_PLAN=2
+readonly EXIT_ERROR=3
+
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # When installed globally, GOLEM_DIR is ~/.golem
 # When run from source, it's the parent of bin/
@@ -29,9 +35,103 @@ GREEN='\033[0;32m'
 YELLOW='\033[0;33m'
 BLUE='\033[0;34m'
 CYAN='\033[0;36m'
+BOLD='\033[1m'
 DIM='\033[2m'
 NC='\033[0m'
 
+# Terminal width for consistent formatting
+TERM_WIDTH=60
+
+# Helper: print a horizontal rule
+hr() {
+    local char="${1:-━}"
+    local color="${2:-$CYAN}"
+    printf "${color}"
+    printf '%*s' "$TERM_WIDTH" '' | tr ' ' "$char"
+    printf "${NC}\n"
+}
+
+# Helper: print centered text
+center() {
+    local text="$1"
+    local color="${2:-$NC}"
+    local text_len=${#text}
+    local padding=$(( (TERM_WIDTH - text_len) / 2 ))
+    printf "${color}%*s%s%*s${NC}\n" "$padding" '' "$text" "$padding" ''
+}
+
+# Helper: print a header box
+header_box() {
+    local title="$1"
+    local color="${2:-$CYAN}"
+    echo ""
+    hr "━" "$color"
+    center "$title" "$color"
+    hr "━" "$color"
+}
+
+# Helper: print status line with icon
+status_line() {
+    local icon="$1"
+    local color="$2"
+    local text="$3"
+    echo -e "  ${color}${icon}${NC}  ${text}"
+}
+
+# Helper: print a key-value line
+kv_line() {
+    local key="$1"
+    local value="$2"
+    local key_color="${3:-$DIM}"
+    printf "  ${key_color}%-12s${NC} %s\n" "$key" "$value"
+}
+
+# Audit logging
+log_event() {
+    local event="$1"
+    local details="${2:-}"
+    local log_file=".golem/golem.log"
+    [[ -d ".golem" ]] && echo "[$(date -Iseconds)] $event: $details" >> "$log_file"
+}
+
+# Robust completion detection
+is_plan_complete() {
+    local plan=".golem/IMPLEMENTATION_PLAN.md"
+    [[ ! -f "$plan" ]] && return $EXIT_NO_PLAN
+
+    # Count unchecked boxes (any format: - [ ], * [ ], ### [ ], etc.)
+    # Note: grep -c returns exit 1 when count is 0, so we need || true to prevent pipefail exit
+    local unchecked
+    unchecked=$(grep -ciE '\[ \]' "$plan" 2>/dev/null | tr -d '[:space:]' || true)
+    [[ -z "$unchecked" ]] && unchecked=0
+
+    # Count checked boxes to verify plan isn't empty
+    local checked
+    checked=$(grep -ciE '\[[xX]\]' "$plan" 2>/dev/null | tr -d '[:space:]' || true)
+    [[ -z "$checked" ]] && checked=0
+
+    if [[ "$unchecked" -eq 0 ]] && [[ "$checked" -gt 0 ]]; then
+        return $EXIT_COMPLETE
+    fi
+    return $EXIT_INCOMPLETE
+}
+
+# Get task counts for display
+get_task_counts() {
+    local plan=".golem/IMPLEMENTATION_PLAN.md"
+    local unchecked=0
+    local checked=0
+
+    if [[ -f "$plan" ]]; then
+        unchecked=$(grep -ciE '\[ \]' "$plan" 2>/dev/null | tr -d '[:space:]' || true)
+        checked=$(grep -ciE '\[[xX]\]' "$plan" 2>/dev/null | tr -d '[:space:]' || true)
+        [[ -z "$unchecked" ]] && unchecked=0
+        [[ -z "$checked" ]] && checked=0
+    fi
+
+    echo "$unchecked $checked"
+}
+
 print_banner() {
     echo ""
     echo -e "${CYAN}"
@@ -54,6 +154,7 @@ print_usage() {
     echo "  run build         Run autonomous build loop"
     echo "  simplify [path]   Run code simplifier"
     echo "  status            Show project status"
+    echo "  status --check    Exit 0 if complete, 1 if incomplete, 2 if no plan"
     echo ""
     echo -e "${BLUE}Options:${NC}"
     echo "  --install         Install golem to current project"
@@ -65,13 +166,21 @@ print_usage() {
     echo "  1. claude → /golem:spec    Define requirements (interactive)"
     echo "  2. golem run plan          Generate implementation plan"
     echo "  3. golem run build         Autonomous build loop"
+    echo ""
+    echo -e "${BLUE}Scripting:${NC}"
+    echo "  golem status --check && echo 'Done!'    # Check completion"
+    echo "  while ! golem status --check; do        # Loop until complete"
+    echo "    golem run build --iterations 1"
+    echo "  done"
 }
 
 # Check if golem is installed in current project
 check_installed() {
     if [[ ! -d ".golem" ]]; then
-        echo -e "${RED}Error: Golem not installed in this project.${NC}"
-        echo -e "Run: ${CYAN}golem --install${NC}"
+        echo ""
+        status_line "✗" "$RED" "Golem not installed in this project"
+        echo -e "     ${DIM}Run: golem --install${NC}"
+        echo ""
         exit 1
     fi
 }
@@ -79,13 +188,13 @@ check_installed() {
 # Install golem to current project
 cmd_install() {
     print_banner
-    echo -e "${BLUE}Installing golem...${NC}"
+    header_box "INSTALLING" "$BLUE"
     echo ""
 
     # Create directories
     mkdir -p .golem/prompts
     mkdir -p .golem/agents
-    mkdir -p specs
+    mkdir -p .golem/specs
 
     # Copy prompts and agents
     local copied_agents=false
@@ -105,8 +214,8 @@ cmd_install() {
     fi
 
     # Create AGENTS.md if it doesn't exist
-    if [[ ! -f "AGENTS.md" ]]; then
-        cat > AGENTS.md << 'EOF'
+    if [[ ! -f ".golem/AGENTS.md" ]]; then
+        cat > .golem/AGENTS.md << 'EOF'
 # Operational Guide
 
 ## Commands
@@ -134,14 +243,14 @@ npm run build
 ## Learnings
 <!-- Updated during build iterations -->
 EOF
-        echo -e "${GREEN}✓${NC} Created AGENTS.md"
+        echo -e "${GREEN}✓${NC} Created .golem/AGENTS.md"
     fi
 
     # Auto-detect project type
     detect_project
 
     echo -e "${GREEN}✓${NC} Created .golem/ directory"
-    echo -e "${GREEN}✓${NC} Created specs/ directory"
+    echo -e "${GREEN}✓${NC} Created .golem/specs/ directory"
     echo ""
     echo -e "${BLUE}Next steps:${NC}"
     echo -e "  1. Run ${CYAN}claude${NC} then ${CYAN}/golem:spec${NC} to define requirements"
@@ -168,7 +277,7 @@ detect_project() {
         fi
 
         # Update AGENTS.md with detected commands
-        cat > AGENTS.md << EOF
+        cat > .golem/AGENTS.md << EOF
 # Operational Guide
 
 ## Commands
@@ -178,28 +287,28 @@ detect_project() {
 ${test_cmd}
 \`\`\`
 EOF
-        [[ -n "$typecheck_cmd" ]] && cat >> AGENTS.md << EOF
+        [[ -n "$typecheck_cmd" ]] && cat >> .golem/AGENTS.md << EOF
 
 ### Type Checking
 \`\`\`bash
 ${typecheck_cmd}
 \`\`\`
 EOF
-        [[ -n "$lint_cmd" ]] && cat >> AGENTS.md << EOF
+        [[ -n "$lint_cmd" ]] && cat >> .golem/AGENTS.md << EOF
 
 ### Linting
 \`\`\`bash
 ${lint_cmd}
 \`\`\`
 EOF
-        [[ -n "$build_cmd" ]] && cat >> AGENTS.md << EOF
+        [[ -n "$build_cmd" ]] && cat >> .golem/AGENTS.md << EOF
 
 ### Build
 \`\`\`bash
 ${build_cmd}
 \`\`\`
 EOF
-        cat >> AGENTS.md << 'EOF'
+        cat >> .golem/AGENTS.md << 'EOF'
 
 ## Learnings
 <!-- Updated during build iterations -->
@@ -214,16 +323,16 @@ EOF
 # Show spec workflow hint
 cmd_spec() {
     print_banner
-    echo -e "${BLUE}Spec Builder${NC}"
+    header_box "SPEC BUILDER" "$BLUE"
     echo ""
-    echo -e "To build specs, run ${CYAN}claude${NC} and use the ${CYAN}/golem:spec${NC} command."
+    echo -e "  To build specs, run ${CYAN}claude${NC} and use ${CYAN}/golem:spec${NC}"
     echo ""
-    echo -e "${DIM}Workflow:${NC}"
-    echo -e "  1. ${CYAN}claude${NC}              - Start Claude Code"
-    echo -e "  2. ${CYAN}/golem:spec${NC}         - Build specs through conversation"
-    echo -e "  3. ${CYAN}exit${NC}                - Exit when done"
-    echo -e "  4. ${CYAN}golem run plan${NC}      - Generate implementation plan"
-    echo -e "  5. ${CYAN}golem run build${NC}     - Run autonomous build loop"
+    echo -e "  ${BOLD}Workflow${NC}"
+    echo -e "    ${DIM}1.${NC} claude              ${DIM}Start Claude Code${NC}"
+    echo -e "    ${DIM}2.${NC} /golem:spec         ${DIM}Build specs interactively${NC}"
+    echo -e "    ${DIM}3.${NC} exit                ${DIM}Exit when done${NC}"
+    echo -e "    ${DIM}4.${NC} golem run plan      ${DIM}Generate implementation plan${NC}"
+    echo -e "    ${DIM}5.${NC} golem run build     ${DIM}Run autonomous build loop${NC}"
     echo ""
 }
 
@@ -271,55 +380,34 @@ cmd_run() {
 
 run_plan_mode() {
     print_banner
-    echo -e "${BLUE}Running planning mode...${NC}"
-    echo -e "${DIM}Analyzing specs and creating implementation plan.${NC}"
+    header_box "PLANNING" "$BLUE"
+    echo ""
+    echo -e "  ${DIM}Analyzing specs and creating implementation plan...${NC}"
     echo ""
 
-    # Build prompt file (Ralph pattern: cat file | claude)
-    local prompt_file=$(mktemp)
-    trap "rm -f $prompt_file" EXIT
-
-    cat > "$prompt_file" << 'PROMPT_HEADER'
-You are in PLANNING MODE. Your job is to analyze the specs and create IMPLEMENTATION_PLAN.md.
-
-DO NOT implement anything. Only create the plan.
-
-PROMPT_HEADER
-
-    # Add planning prompt if available
+    # Find prompt file (uses @file references for context)
+    local prompt_file=""
     if [[ -f ".golem/prompts/PROMPT_plan.md" ]]; then
-        cat .golem/prompts/PROMPT_plan.md >> "$prompt_file"
-        echo "" >> "$prompt_file"
-    fi
-
-    echo "---" >> "$prompt_file"
-    echo "" >> "$prompt_file"
-    echo "# Specs" >> "$prompt_file"
-    echo "" >> "$prompt_file"
-
-    for spec in specs/*.md; do
-        if [[ -f "$spec" ]]; then
-            echo "## $(basename "$spec" .md)" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            cat "$spec" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        fi
-    done
-
-    if [[ -f "AGENTS.md" ]]; then
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Operational Guide" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        cat AGENTS.md >> "$prompt_file"
+        prompt_file=".golem/prompts/PROMPT_plan.md"
+    elif [[ -f "$GOLEM_DIR/golem/prompts/PROMPT_plan.md" ]]; then
+        prompt_file="$GOLEM_DIR/golem/prompts/PROMPT_plan.md"
+    else
+        status_line "✗" "$RED" "No PROMPT_plan.md found. Run golem --install first."
+        exit 1
     fi
 
-    # Run planning (Ralph pattern: cat PROMPT | claude -p)
-    cat "$prompt_file" | claude -p --allowedTools "Read,Write,Edit,Glob,Grep"
+    # Ralph pattern: cat PROMPT | claude -p
+    cat "$prompt_file" | claude -p \
+        --dangerously-skip-permissions \
+        --model opus \
+        --verbose
 
     echo ""
-    echo -e "${GREEN}Planning complete.${NC}"
-    echo -e "Run ${CYAN}golem run build${NC} to start implementation."
+    header_box "PLANNING COMPLETE" "$GREEN"
+    echo ""
+    status_line "✓" "$GREEN" "Implementation plan created"
+    echo -e "  ${DIM}Next:${NC} golem run build"
+    echo ""
 }
 
 run_build_loop() {
@@ -329,181 +417,96 @@ run_build_loop() {
     print_banner
 
     # Verify prerequisites
-    if [[ ! -f "IMPLEMENTATION_PLAN.md" ]]; then
-        echo -e "${YELLOW}No implementation plan found.${NC}"
-        echo -e "Run ${CYAN}golem run plan${NC} first."
-        exit 1
+    if [[ ! -f ".golem/IMPLEMENTATION_PLAN.md" ]]; then
+        echo ""
+        status_line "!" "$YELLOW" "No implementation plan found"
+        echo -e "     ${DIM}Run: golem run plan${NC}"
+        echo ""
+        log_event "BUILD_ABORT" "No implementation plan found"
+        exit $EXIT_NO_PLAN
     fi
 
-    if [[ ! -d "specs" ]] || [[ -z "$(ls -A specs/*.md 2>/dev/null)" ]]; then
-        echo -e "${YELLOW}No specs found.${NC}"
-        echo -e "Run ${CYAN}/golem:spec${NC} in Claude first."
-        exit 1
+    if [[ ! -d ".golem/specs" ]] || [[ -z "$(ls -A .golem/specs/*.md 2>/dev/null)" ]]; then
+        echo ""
+        status_line "!" "$YELLOW" "No specs found"
+        echo -e "     ${DIM}Run: /golem:spec in Claude first${NC}"
+        echo ""
+        log_event "BUILD_ABORT" "No specs found"
+        exit $EXIT_ERROR
     fi
 
-    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "${CYAN}  BUILD LOOP STARTED${NC}"
-    if [[ "$simplify" == "true" ]]; then
-        echo -e "${CYAN}  Mode: Implement → Simplify (2 steps per iteration)${NC}"
+    # Find prompt file
+    local build_prompt=""
+    if [[ -f ".golem/prompts/PROMPT_build.md" ]]; then
+        build_prompt=".golem/prompts/PROMPT_build.md"
+    elif [[ -f "$GOLEM_DIR/golem/prompts/PROMPT_build.md" ]]; then
+        build_prompt="$GOLEM_DIR/golem/prompts/PROMPT_build.md"
+    else
+        status_line "✗" "$RED" "No PROMPT_build.md found"
+        echo -e "     ${DIM}Run: golem --install${NC}"
+        log_event "BUILD_ABORT" "No PROMPT_build.md found"
+        exit $EXIT_ERROR
     fi
-    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+
+    header_box "BUILD LOOP" "$CYAN"
 
     local iteration=0
     local start_time=$(date +%s)
-    local prompt_file=$(mktemp)
-    trap "rm -f $prompt_file" EXIT
+    log_event "BUILD_START" "max_iterations=${max_iterations:-unlimited} simplify=$simplify"
 
+    # Ralph loop: while :; do cat PROMPT | claude -p; done
     while true; do
+        # Check completion BEFORE incrementing iteration
+        if is_plan_complete; then
+            log_event "BUILD_COMPLETE" "All tasks done after $iteration iterations"
+            break
+        fi
+
         iteration=$((iteration + 1))
 
         # Check iteration limit
         if [[ -n "$max_iterations" ]] && [[ $iteration -gt $max_iterations ]]; then
-            echo -e "${YELLOW}Reached iteration limit ($max_iterations). Stopping.${NC}"
+            echo ""
+            status_line "◦" "$YELLOW" "Reached iteration limit ($max_iterations)"
+            log_event "BUILD_LIMIT" "Stopped at iteration $iteration (limit: $max_iterations)"
             break
         fi
 
-        # Check remaining tasks
-        local remaining=$(grep -c '^\- \[ \]' IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0")
-        if [[ "$remaining" == "0" ]]; then
-            echo -e "${GREEN}All tasks completed!${NC}"
-            break
-        fi
+        # Get task counts for display
+        read -r remaining checked <<< "$(get_task_counts)"
 
         echo ""
-        echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-        echo -e "${BLUE}  ITERATION $iteration  │  $remaining tasks remaining${NC}"
-        echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+        hr "─" "$BLUE"
+        local total=$((remaining + checked))
+        local progress_pct=0
+        [[ $total -gt 0 ]] && progress_pct=$((checked * 100 / total))
+        echo -e "${BLUE}  ▸ Iteration ${BOLD}$iteration${NC}${BLUE}    Tasks: ${GREEN}$checked${BLUE}/${total} ${DIM}($progress_pct%)${NC}"
+        hr "─" "$BLUE"
+
+        local iter_start=$(date +%s)
+        log_event "ITERATION_START" "iteration=$iteration remaining=$remaining"
+
+        # Ralph pattern: cat PROMPT | claude -p
+        local claude_exit=0
+        cat "$build_prompt" | claude -p \
+            --dangerously-skip-permissions \
+            --model opus \
+            --verbose || claude_exit=$?
+
+        local iter_end=$(date +%s)
+        local iter_duration=$((iter_end - iter_start))
+        log_event "ITERATION_END" "iteration=$iteration exit_code=$claude_exit duration=${iter_duration}s"
+
+        # Push changes after each iteration (like Ralph)
+        local current_branch=$(git branch --show-current)
+        git push origin "$current_branch" 2>/dev/null || {
+            echo -e "  ${DIM}Creating remote branch...${NC}"
+            git push -u origin "$current_branch" 2>/dev/null || true
+        }
 
-        # ═══════════════════════════════════════════════════════════
-        # STEP 1: IMPLEMENT
-        # ═══════════════════════════════════════════════════════════
         echo ""
-        echo -e "${GREEN}▶ Step 1: Implement${NC}"
-
-        # Build prompt file (Ralph pattern)
-        cat > "$prompt_file" << 'IMPLEMENT_HEADER'
-You are in BUILD MODE. Complete ONE task from the plan.
-
-DO NOT commit - just implement, test, update the plan, and stage changes.
-The commit will happen after simplification.
-
-IMPLEMENT_HEADER
-
-        # Add build prompt if available
-        if [[ -f ".golem/prompts/PROMPT_build.md" ]]; then
-            cat .golem/prompts/PROMPT_build.md >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        fi
-
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Specs" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-
-        for spec in specs/*.md; do
-            if [[ -f "$spec" ]]; then
-                echo "## $(basename "$spec" .md)" >> "$prompt_file"
-                echo "" >> "$prompt_file"
-                cat "$spec" >> "$prompt_file"
-                echo "" >> "$prompt_file"
-            fi
-        done
-
-        if [[ -f "AGENTS.md" ]]; then
-            echo "---" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "# Operational Guide" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            cat AGENTS.md >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        fi
-
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Implementation Plan" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        cat IMPLEMENTATION_PLAN.md >> "$prompt_file"
-
-        # Run implementation (Ralph pattern: cat PROMPT | claude -p)
-        cat "$prompt_file" | claude -p --dangerously-skip-permissions
-
-        local exit_code=$?
-        if [[ $exit_code -ne 0 ]]; then
-            echo -e "${RED}Implementation step exited with error code $exit_code${NC}"
-        fi
-
-        # ═══════════════════════════════════════════════════════════
-        # STEP 2: SIMPLIFY + COMMIT
-        # ═══════════════════════════════════════════════════════════
+        echo -e "${DIM}  ─────────────────────────────────────────────────────────${NC}"
         echo ""
-        echo -e "${GREEN}▶ Step 2: Simplify + Commit${NC}"
-
-        # Get staged files
-        local staged_files=$(git diff --cached --name-only 2>/dev/null | grep -E '\.(ts|tsx|js|jsx|py|go|rs|vue)$' | grep -v '\.test\.' | grep -v '\.spec\.' | head -10)
-
-        # Build simplify prompt file
-        cat > "$prompt_file" << 'SIMPLIFY_HEADER'
-You are in SIMPLIFY + COMMIT MODE.
-
-SIMPLIFY_HEADER
-
-        if [[ "$simplify" == "true" ]] && [[ -n "$staged_files" ]]; then
-            cat >> "$prompt_file" << 'SIMPLIFY_INSTRUCTIONS'
-1. Simplify the staged source files (not tests)
-2. Run tests to verify no regressions
-3. Stage any changes from simplification
-4. Create a single commit with a comprehensive message
-
-SIMPLIFY_INSTRUCTIONS
-
-            # Add code-simplifier agent if available
-            if [[ -f ".golem/agents/code-simplifier.md" ]]; then
-                cat .golem/agents/code-simplifier.md >> "$prompt_file"
-                echo "" >> "$prompt_file"
-            fi
-
-            echo "---" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "# Staged source files to simplify" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "$staged_files" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-        else
-            cat >> "$prompt_file" << 'NO_SIMPLIFY'
-No source files to simplify. Just create the commit.
-
-Use conventional commit format with a descriptive body.
-
-NO_SIMPLIFY
-        fi
-
-        # Get current task for commit context
-        local current_task=$(grep -A3 '^\- \[ \]' IMPLEMENTATION_PLAN.md 2>/dev/null | head -4)
-        echo "---" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "# Task that was just completed" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-        echo "$current_task" >> "$prompt_file"
-        echo "" >> "$prompt_file"
-
-        if [[ -f "AGENTS.md" ]]; then
-            echo "---" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            echo "# Operational Guide (for running tests)" >> "$prompt_file"
-            echo "" >> "$prompt_file"
-            cat AGENTS.md >> "$prompt_file"
-        fi
-
-        # Run simplify + commit (Ralph pattern)
-        cat "$prompt_file" | claude -p --dangerously-skip-permissions
-
-        exit_code=$?
-        if [[ $exit_code -ne 0 ]]; then
-            echo -e "${RED}Simplify + commit step exited with error code $exit_code${NC}"
-        fi
-
-        # Brief pause between iterations
-        sleep 2
     done
 
     local end_time=$(date +%s)
@@ -511,18 +514,25 @@ NO_SIMPLIFY
     local minutes=$((duration / 60))
     local seconds=$((duration % 60))
 
+    read -r remaining checked <<< "$(get_task_counts)"
+    local total=$((remaining + checked))
+
+    echo ""
+    header_box "BUILD COMPLETE" "$GREEN"
     echo ""
-    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "${CYAN}  BUILD LOOP COMPLETE${NC}"
-    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "  Iterations: $iteration"
-    echo -e "  Duration: ${minutes}m ${seconds}s"
-
-    if [[ -f "IMPLEMENTATION_PLAN.md" ]]; then
-        local total=$(grep -c '^\- \[' IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0")
-        local done=$(grep -c '^\- \[x\]' IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0")
-        echo -e "  Tasks: $done / $total completed"
+    kv_line "Iterations" "$iteration"
+    kv_line "Duration" "${minutes}m ${seconds}s"
+    kv_line "Tasks" "$checked / $total completed"
+
+    if [[ $remaining -eq 0 ]]; then
+        echo ""
+        status_line "✓" "$GREEN" "All tasks completed successfully"
+    else
+        echo ""
+        status_line "◦" "$YELLOW" "$remaining tasks remaining"
     fi
+
+    log_event "BUILD_SUMMARY" "iterations=$iteration duration=${duration}s completed=$checked remaining=$remaining"
     echo ""
 }
 
@@ -530,7 +540,9 @@ cmd_simplify() {
     local target="${1:-.}"
     check_installed
     print_banner
-    echo -e "${BLUE}Running code simplifier on: $target${NC}"
+    header_box "SIMPLIFY" "$BLUE"
+    echo ""
+    echo -e "  ${DIM}Target:${NC} $target"
     echo ""
 
     if [[ -f ".golem/agents/code-simplifier.md" ]]; then
@@ -543,44 +555,72 @@ cmd_simplify() {
 }
 
 cmd_status() {
+    local check_only=false
+
+    # Parse options
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            --check)
+                check_only=true
+                shift
+                ;;
+            *)
+                shift
+                ;;
+        esac
+    done
+
+    # --check mode: just return exit code, no output
+    if [[ "$check_only" == "true" ]]; then
+        is_plan_complete
+        exit $?
+    fi
+
     check_installed
     print_banner
-
-    echo -e "${BLUE}PROJECT STATUS${NC}"
-    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    header_box "PROJECT STATUS" "$BLUE"
     echo ""
 
     # Specs
-    echo -e "${BLUE}Specs${NC}"
-    if [[ -d "specs" ]]; then
-        local count=$(ls -1 specs/*.md 2>/dev/null | wc -l | tr -d ' ')
-        echo "  Files: $count"
-        for f in specs/*.md; do
-            [[ -f "$f" ]] && echo "    • $(basename "$f" .md)"
+    echo -e "  ${BOLD}Specs${NC}"
+    if [[ -d ".golem/specs" ]]; then
+        local count=$(ls -1 .golem/specs/*.md 2>/dev/null | wc -l | tr -d ' ')
+        kv_line "Files" "$count"
+        for f in .golem/specs/*.md; do
+            [[ -f "$f" ]] && echo -e "    ${DIM}•${NC} $(basename "$f" .md)"
         done
     else
-        echo "  No specs/ directory"
+        echo -e "    ${DIM}No specs directory${NC}"
     fi
     echo ""
 
     # Plan
-    echo -e "${BLUE}Implementation Plan${NC}"
-    if [[ -f "IMPLEMENTATION_PLAN.md" ]]; then
-        local total=$(grep -c '^\- \[' IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0")
-        local done=$(grep -c '^\- \[x\]' IMPLEMENTATION_PLAN.md 2>/dev/null || echo "0")
-        local remaining=$((total - done))
-        echo "  Total:     $total tasks"
-        echo "  Completed: $done"
-        echo "  Remaining: $remaining"
+    echo -e "  ${BOLD}Implementation Plan${NC}"
+    if [[ -f ".golem/IMPLEMENTATION_PLAN.md" ]]; then
+        read -r remaining checked <<< "$(get_task_counts)"
+        local total=$((remaining + checked))
+        local progress_pct=0
+        [[ $total -gt 0 ]] && progress_pct=$((checked * 100 / total))
+
+        kv_line "Progress" "$checked / $total tasks ($progress_pct%)"
+
+        if is_plan_complete; then
+            status_line "✓" "$GREEN" "Complete"
+        else
+            status_line "◦" "$YELLOW" "In progress ($remaining remaining)"
+        fi
     else
-        echo "  No plan yet - run 'golem run plan'"
+        echo -e "    ${DIM}No plan yet${NC}"
+        echo -e "    ${DIM}Run: golem run plan${NC}"
     fi
     echo ""
 
     # Git
     if git rev-parse --is-inside-work-tree &>/dev/null; then
-        echo -e "${BLUE}Recent Commits${NC}"
-        git log --oneline -5 2>/dev/null || echo "  No commits yet"
+        echo -e "  ${BOLD}Recent Commits${NC}"
+        git log --oneline -5 2>/dev/null | while read -r line; do
+            echo -e "    ${DIM}•${NC} $line"
+        done || echo -e "    ${DIM}No commits yet${NC}"
     fi
     echo ""
 }
@@ -613,7 +653,8 @@ main() {
             cmd_simplify "$@"
             ;;
         status)
-            cmd_status
+            shift
+            cmd_status "$@"
             ;;
         "")
             # No command - just launch claude

package/bin/install.cjs

@@ -127,11 +127,17 @@ golem() {
       content = fs.readFileSync(configPath, 'utf8');
     }
 
-    // Remove old golem function/alias
-    if (content.includes('golem()') || content.includes('# Golem alias')) {
-      content = content.replace(/\n# Golem alias for Claude Code\ngolem\(\) \{[\s\S]*?\n\}\n/g, '');
-      content = content.replace(/\n# Golem alias.*\nalias golem=.*\n/g, '');
-    }
+    // Remove ALL old golem function/alias definitions
+    // Match golem() function blocks (various formats)
+    content = content.replace(/\n# Golem[^\n]*\n# Installed by:[^\n]*\ngolem\(\) \{[\s\S]*?\n\}\n?/g, '\n');
+    content = content.replace(/\n# Golem alias for Claude Code\ngolem\(\) \{[\s\S]*?\n\}\n?/g, '\n');
+    // Match old-style alias definitions (from golem --install)
+    content = content.replace(/\n# Added by: golem --install[^\n]*\n[^\n]*\nalias golem=[^\n]*\n?/g, '\n');
+    content = content.replace(/\n# Golem alias[^\n]*\nalias golem=[^\n]*\n?/g, '\n');
+    // Clean up any standalone alias golem= lines
+    content = content.replace(/\nalias golem=[^\n]*\n?/g, '\n');
+    // Clean up multiple consecutive newlines
+    content = content.replace(/\n{3,}/g, '\n\n');
 
     content = content.trimEnd() + '\n' + golemFunction;
     fs.writeFileSync(configPath, content);

package/golem/prompts/PROMPT_build.md

@@ -1,60 +1,47 @@
-# Ralph Build Mode
-
-You are operating in **build mode** - your job is to implement one task from the plan and validate it works.
-
-**Note:** Do NOT commit. Code simplification and commit happen in a separate step.
-
-## Execution Flow
-
-1. **Orient** - Read the specs and implementation plan below
-2. **Select** - Pick the highest-priority incomplete task (marked `[ ]`)
-3. **Investigate** - Search relevant source code to understand context
-4. **Implement** - Make the changes required for this task
-5. **Validate** - Run all backpressure gates (tests, typecheck, lint)
-6. **Fix** - If validation fails, fix issues and re-validate
-7. **Update Plan** - Mark task complete, add any discoveries
-8. **Stage** - Run `git add` on changed files (but DO NOT commit)
-
-## Rules
-
-### Task Selection
-- Always pick the **first** incomplete task unless it has unmet dependencies
-- Never skip tasks or cherry-pick based on preference
-- If blocked, note the blocker and select the next available task
-
-### Implementation
-- Implement ONLY what the task requires - no scope creep
-- Follow existing code patterns and conventions
-- Write tests alongside implementation code
-- Keep changes minimal and focused
-
-### Validation (Backpressure)
-Run these commands in order. ALL must pass before proceeding:
-1. Tests: `{test_command}`
-2. Type check: `{typecheck_command}` (if configured)
-3. Lint: `{lint_command}` (if configured)
-4. Build: `{build_command}` (if configured)
-
-If any gate fails:
-- Read the error carefully
-- Fix the issue
-- Re-run ALL gates from the beginning
-- Repeat until all pass
-
-### Plan Updates
-Edit `IMPLEMENTATION_PLAN.md`:
-- Change `[ ]` to `[x]` for completed task
-- Add notes about discoveries or blockers encountered
-- Add new tasks if implementation revealed missing work
-
-### Staging (No Commit!)
-Run `git add` on the files you changed, but DO NOT commit.
-The commit will happen after the simplification step.
-
-## Important
-
-- Complete ONE task per iteration, then exit
-- Fresh context on next iteration will continue from updated plan
-- If stuck on a task for more than 3 attempts, mark it blocked and move on
-- Trust the tests - if they pass, the implementation is correct
-- DO NOT commit - simplification step will handle that
+# Build Mode
+
+You are in BUILD MODE. Implement ONE task from the plan, then exit.
+
+## Phase 0: Orient
+
+Study these files to understand context:
+- @specs/* - All specification files
+- @AGENTS.md - Operational commands (test/build/lint)
+- @IMPLEMENTATION_PLAN.md - Current task list
+
+## Phase 1: Select Task
+
+1. Read IMPLEMENTATION_PLAN.md
+2. Pick the first incomplete task (marked `- [ ]`)
+3. Do NOT assume something is not implemented - search first
+
+## Phase 2: Implement
+
+1. Search codebase to understand existing patterns
+2. Make the required changes
+3. Follow existing code patterns exactly
+4. Write tests alongside implementation
+
+## Phase 3: Validate (Backpressure)
+
+Run commands from AGENTS.md in order. ALL must pass:
+1. Tests
+2. Type check (if configured)
+3. Lint (if configured)
+
+If ANY fails: fix the issue, then re-run ALL validation from the beginning.
+
+## Phase 4: Complete
+
+1. Update IMPLEMENTATION_PLAN.md - mark task `- [x]`
+2. Update AGENTS.md learnings if you discovered something useful
+3. Commit changes with descriptive message
+4. Exit
+
+## Phase 999: Critical Rules
+
+- Complete ONE task only per iteration
+- Do NOT skip validation - all gates must pass
+- Do NOT assume code doesn't exist - always search first
+- Trust the tests - passing = correct
+- Exit after committing so next iteration gets fresh context

package/golem/prompts/PROMPT_plan.md

@@ -1,84 +1,54 @@
-# Ralph Planning Mode
-
-You are operating in **planning mode** - your job is to analyze specs versus existing code and create/update the implementation plan.
-
-## Execution Flow
-
-1. **Read Specs** - Understand all requirements from specs/*.md
-2. **Analyze Code** - Search the codebase to understand current state
-3. **Gap Analysis** - Identify what needs to be built vs. what exists
-4. **Prioritize** - Order tasks by dependencies and criticality
-5. **Generate Plan** - Create/update IMPLEMENTATION_PLAN.md
-
-## Rules
-
-### Spec Analysis
-- Read each spec file completely
-- Extract concrete requirements (must have, should have)
-- Note acceptance criteria and constraints
-- Identify dependencies between specs
-
-### Code Analysis
-- Search for existing implementations
-- Understand current architecture and patterns
-- Identify reusable components
-- Note technical debt or issues
-
-### Gap Analysis
-For each requirement, determine:
-- **Done**: Already implemented and tested
-- **Partial**: Partially implemented, needs completion
-- **Missing**: Not implemented at all
-- **Blocked**: Depends on something not yet built
-
-### Task Generation
-Each task should be:
-- **Atomic** - Completable in one focused session
-- **Testable** - Has clear verification criteria
-- **Scoped** - Affects 1-3 files typically
-- **Independent** - Minimal dependencies on other tasks
-
-Bad task: "Implement authentication"
-Good task: "Implement user registration with email/password"
-
-### Priority Rules
-Order tasks by:
-1. **Critical path** - What blocks other work?
-2. **Dependencies** - What must be built first?
-3. **Risk** - Tackle unknowns early
-4. **Value** - Higher value tasks before nice-to-haves
+# Planning Mode
 
-### Plan Format
+You are in PLANNING MODE. Analyze specs vs existing code and create IMPLEMENTATION_PLAN.md.
 
-Write `IMPLEMENTATION_PLAN.md` in this format:
+## Phase 0: Orient
 
-```markdown
-# Implementation Plan
+Study these files first:
+- @specs/* - All specification files
+- @AGENTS.md - Operational commands
+- @IMPLEMENTATION_PLAN.md - Current plan (if exists)
+
+## Phase 1: Gap Analysis
+
+1. Read ALL spec files thoroughly
+2. Search the codebase extensively - use parallel subagents
+3. Do NOT assume something is missing - verify by searching
+4. Compare specs vs existing code
+5. Identify what's implemented vs what's missing
+
+## Phase 2: Create Plan
 
-Generated: {timestamp}
-Based on: specs/*.md
+Write `IMPLEMENTATION_PLAN.md` with prioritized tasks:
 
-## Status
-- Total tasks: N
-- Completed: 0
-- Remaining: N
+```markdown
+# Implementation Plan
 
 ## Tasks
 
-### [ ] 1. {Task title}
-Priority: Critical|High|Medium|Low
-Files: {expected files to create/modify}
-Notes: {implementation hints, constraints}
-Depends on: {task numbers if any}
+- [ ] 1. {Task title}
+  Priority: Critical|High|Medium|Low
+  Files: {files to create/modify}
+  Why: {capture the reasoning}
 
-### [ ] 2. {Next task}
-...
+- [ ] 2. {Next task}
+  ...
 ```
 
-## Important
+Order tasks by:
+1. Dependencies first (what blocks other work)
+2. Critical path (what's essential for MVP)
+3. Value (highest impact)
+
+## Phase 3: Exit
+
+After writing the plan, exit immediately.
+
+## Phase 999: Critical Rules
 
-- Do NOT implement anything in planning mode
-- Do NOT modify source code
-- ONLY create/update IMPLEMENTATION_PLAN.md
+- Do NOT assume something is not implemented - search first
+- Each task must be atomic (completable in one iteration)
+- Do NOT modify any source code
+- Do NOT implement anything - only create the plan
 - Be thorough - missing tasks cause problems later
-- Be realistic - tasks should be achievable in one iteration
+- Capture "the why" for each task

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "golem-cc",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Autonomous coding loop with Claude - structured specs, ralph loop execution, code simplification",
   "bin": {
     "golem-cc": "./bin/install.cjs"