kenaz 0.3.21 → 0.3.23

package/core/dev/scripts/multi_agent_scheduler.sh

@@ -1,1344 +0,0 @@
-#!/usr/bin/env bash
-# ============================================================
-# Multi-Agent Parallel Scheduler (macOS/Linux version)
-# ============================================================
-# Equivalent of multi_agent_scheduler.ps1
-# Compatible with bash 3.2+ (macOS default)
-#
-# Launches multiple Claude Agents in parallel for task execution
-# - Auto-assigns non-conflicting tasks to multiple agents
-# - Uses path locking to prevent conflicts
-# - Each agent works on an independent branch
-# ============================================================
-
-set -uo pipefail
-
-# --- Default Parameters ---
-MAX_AGENTS=3
-POLL_INTERVAL=30
-TASK_TIMEOUT=60
-DRY_RUN=false
-SINGLE_RUN=false
-WORKING_DIRECTORY=""
-STANDALONE=false
-
-# --- Parse Arguments ---
-while [ $# -gt 0 ]; do
-    case "$1" in
-        --max-agents) MAX_AGENTS="$2"; shift 2 ;;
-        --poll-interval) POLL_INTERVAL="$2"; shift 2 ;;
-        --task-timeout) TASK_TIMEOUT="$2"; shift 2 ;;
-        --dry-run) DRY_RUN=true; shift ;;
-        --single-run) SINGLE_RUN=true; shift ;;
-        --working-directory|--wd) WORKING_DIRECTORY="$2"; shift 2 ;;
-        --standalone|-s) STANDALONE=true; shift ;;
-        --nopause) shift ;;
-        *) shift ;;
-    esac
-done
-
-# Use KENAZ_PROJECT_PATH env var if WorkingDirectory not specified
-if [ -z "$WORKING_DIRECTORY" ]; then
-    if [ -n "${KENAZ_PROJECT_PATH:-}" ]; then
-        WORKING_DIRECTORY="$KENAZ_PROJECT_PATH"
-    else
-        WORKING_DIRECTORY="$(pwd)"
-    fi
-fi
-
-# --- File Paths ---
-LOG_DIR="$WORKING_DIRECTORY/dev/pipeline/logs"
-LOG_FILE="$LOG_DIR/multi_agent_$(date +%Y-%m-%d).log"
-TASK_QUEUE_FILE="$WORKING_DIRECTORY/dev/pipeline/TASK_QUEUE.json"
-LOCK_STATE_FILE="$WORKING_DIRECTORY/dev/pipeline/LOCK_STATE.json"
-AGENT_STATE_FILE="$WORKING_DIRECTORY/dev/pipeline/AGENT_STATE.json"
-HEARTBEAT_FILE="$WORKING_DIRECTORY/dev/pipeline/DASHBOARD_HEARTBEAT.json"
-STARTUP_LOG="$WORKING_DIRECTORY/multi_agent_startup.log"
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-
-# Ensure log directory exists
-mkdir -p "$LOG_DIR"
-
-# --- Agent tracking via temp directory (bash 3.2 compatible) ---
-# Each agent gets a directory: $TRACKER_DIR/<agent_id>/
-# With files: pid, task_id, branch, start_time, log_file, agent_type
-TRACKER_DIR=$(mktemp -d /tmp/kenaz_agents.XXXXXX)
-
-get_active_agent_ids() {
-    # List all tracked agent IDs
-    if [ -d "$TRACKER_DIR" ]; then
-        ls "$TRACKER_DIR" 2>/dev/null || true
-    fi
-}
-
-get_active_count() {
-    local count=0
-    for d in "$TRACKER_DIR"/*/; do
-        [ -d "$d" ] && count=$((count + 1))
-    done
-    echo "$count"
-}
-
-track_agent() {
-    local agent_id="$1" pid="$2" task_id="$3" branch="$4" agent_type="$5" log_file="$6" task_title="${7:-}"
-    local dir="$TRACKER_DIR/$agent_id"
-    mkdir -p "$dir"
-    echo "$pid" > "$dir/pid"
-    echo "$task_id" > "$dir/task_id"
-    echo "$branch" > "$dir/branch"
-    echo "$(date +%s)" > "$dir/start_time"
-    echo "$log_file" > "$dir/log_file"
-    echo "$agent_type" > "$dir/agent_type"
-    echo "$task_title" > "$dir/task_title"
-}
-
-untrack_agent() {
-    local agent_id="$1"
-    rm -rf "$TRACKER_DIR/$agent_id"
-}
-
-agent_get() {
-    local agent_id="$1" field="$2"
-    cat "$TRACKER_DIR/$agent_id/$field" 2>/dev/null || echo ""
-}
-
-is_task_running() {
-    local task_id="$1"
-    for d in "$TRACKER_DIR"/*/; do
-        [ -d "$d" ] || continue
-        local running_task
-        running_task=$(cat "$d/task_id" 2>/dev/null || echo "")
-        if [ "$running_task" = "$task_id" ]; then
-            return 0
-        fi
-    done
-    return 1
-}
-
-# ============================================================
-# Utility Functions
-# ============================================================
-
-log_msg() {
-    local msg="$1"
-    local level="${2:-INFO}"
-    local timestamp
-    timestamp=$(date "+%Y-%m-%d %H:%M:%S")
-    local log_line="[$timestamp] [$level] $msg"
-
-    case "$level" in
-        ERROR)   printf '\033[31m%s\033[0m\n' "$log_line" ;;
-        WARN)    printf '\033[33m%s\033[0m\n' "$log_line" ;;
-        SUCCESS) printf '\033[32m%s\033[0m\n' "$log_line" ;;
-        *)       echo "$log_line" ;;
-    esac
-
-    echo "$log_line" >> "$LOG_FILE" 2>/dev/null || true
-}
-
-debug_log() {
-    local timestamp
-    timestamp=$(date "+%Y-%m-%d %H:%M:%S")
-    echo "[$timestamp] [${2:-INFO}] $1" >> "$STARTUP_LOG" 2>/dev/null || true
-}
-
-# ============================================================
-# Agent Type Detection
-# ============================================================
-
-get_agent_type() {
-    local task_title="$1"
-    local explicit_type="${2:-}"
-
-    if [ -n "$explicit_type" ]; then
-        echo "$explicit_type"
-        return
-    fi
-
-    local title_lower
-    title_lower=$(echo "$task_title" | tr '[:upper:]' '[:lower:]')
-
-    # Keyword matching
-    for kw in ui ux layout style design css theme color visual icon; do
-        case "$title_lower" in *"$kw"*) echo "designer"; return ;; esac
-    done
-    for kw in api database backend endpoint server sql migration supabase postgres; do
-        case "$title_lower" in *"$kw"*) echo "backend"; return ;; esac
-    done
-    for kw in test qa quality e2e spec coverage; do
-        case "$title_lower" in *"$kw"*) echo "qa"; return ;; esac
-    done
-    for kw in deploy ci/cd monitoring infrastructure docker kubernetes devops; do
-        case "$title_lower" in *"$kw"*) echo "sre"; return ;; esac
-    done
-    for kw in component react frontend tsx jsx hook state page dashboard; do
-        case "$title_lower" in *"$kw"*) echo "developer"; return ;; esac
-    done
-
-    echo "dev"
-}
-
-get_display_name() {
-    case "$1" in
-        developer) echo "Frontend Developer" ;;
-        backend)   echo "Backend Engineer" ;;
-        designer)  echo "UI/UX Designer" ;;
-        qa)        echo "QA Engineer" ;;
-        sre)       echo "SRE Agent" ;;
-        frontend)  echo "Frontend Agent" ;;
-        architect) echo "Architect" ;;
-        *)         echo "Dev Agent" ;;
-    esac
-}
-
-get_dashboard_type() {
-    case "$1" in
-        developer) echo "developer" ;;
-        backend)   echo "backend_engineer" ;;
-        designer)  echo "designer" ;;
-        qa)        echo "qa_engineer" ;;
-        sre)       echo "sre_agent" ;;
-        frontend)  echo "frontend_agent" ;;
-        architect) echo "architect_agent" ;;
-        *)         echo "dev_agent" ;;
-    esac
-}
-
-# ============================================================
-# State Management (via Python for reliable JSON ops)
-# ============================================================
-
-save_lock_state() {
-    local content="$1"
-    python3 -c "
-import json
-from datetime import datetime
-data = json.loads(r'''$content''')
-data['last_updated'] = datetime.now().isoformat()
-with open('$LOCK_STATE_FILE', 'w', encoding='utf-8') as f:
-    json.dump(data, f, indent=2, ensure_ascii=False)
-" 2>/dev/null || true
-}
-
-save_agent_state() {
-    local content="$1"
-    python3 -c "
-import json
-from datetime import datetime
-data = json.loads(r'''$content''')
-data['last_updated'] = datetime.now().isoformat()
-with open('$AGENT_STATE_FILE', 'w', encoding='utf-8') as f:
-    json.dump(data, f, indent=2, ensure_ascii=False)
-" 2>/dev/null || true
-}
-
-add_agent_to_state() {
-    local agent_id="$1"
-    local task_id="$2"
-    local task_title="$3"
-    local branch="$4"
-    local agent_type="$5"
-    local dashboard_type
-    dashboard_type=$(get_dashboard_type "$agent_type")
-
-    python3 << PYEOF
-import json
-from datetime import datetime
-
-state_file = '$AGENT_STATE_FILE'
-try:
-    with open(state_file, 'r', encoding='utf-8') as f:
-        state = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError):
-    state = {'agents': []}
-
-state['agents'] = [a for a in state.get('agents', []) if a.get('id') != '$agent_id']
-state['agents'].append({
-    'id': '$agent_id',
-    'type': '$dashboard_type',
-    'status': 'working',
-    'current_task': '$task_id',
-    'current_operation': $(python3 -c "import json; print(json.dumps('$task_title'))"),
-    'branch': '$branch',
-    'started_at': datetime.now().isoformat(),
-    'task_id': '$task_id',
-    'task_title': $(python3 -c "import json; print(json.dumps('$task_title'))"),
-})
-state['last_updated'] = datetime.now().isoformat()
-
-with open(state_file, 'w', encoding='utf-8') as f:
-    json.dump(state, f, indent=2, ensure_ascii=False)
-PYEOF
-
-    local display_name
-    display_name=$(get_display_name "$agent_type")
-    log_msg "Added agent $agent_id ($display_name) to AGENT_STATE.json (task: $task_id)"
-}
-
-remove_agent_from_state() {
-    local agent_id="$1"
-    python3 -c "
-import json
-from datetime import datetime
-try:
-    with open('$AGENT_STATE_FILE', 'r', encoding='utf-8') as f:
-        state = json.load(f)
-    state['agents'] = [a for a in state.get('agents', []) if a.get('id') != '$agent_id']
-    state['last_updated'] = datetime.now().isoformat()
-    with open('$AGENT_STATE_FILE', 'w', encoding='utf-8') as f:
-        json.dump(state, f, indent=2, ensure_ascii=False)
-except Exception:
-    pass
-" 2>/dev/null || true
-    log_msg "Removed agent $agent_id from AGENT_STATE.json"
-}
-
-# ============================================================
-# Lock Management
-# ============================================================
-
-add_path_locks() {
-    local agent_id="$1"
-    local task_id="$2"
-    shift 2
-    # Remaining args are paths, build a JSON array
-    local paths_json
-    paths_json=$(python3 -c "import json,sys; print(json.dumps(sys.argv[1:]))" "$@")
-
-    python3 << PYEOF
-import json
-from datetime import datetime
-
-lock_file = '$LOCK_STATE_FILE'
-try:
-    with open(lock_file, 'r', encoding='utf-8') as f:
-        state = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError):
-    state = {'locks': []}
-
-paths = json.loads('$paths_json')
-for path in paths:
-    state['locks'].append({
-        'path': path,
-        'agent_id': '$agent_id',
-        'task_id': '$task_id',
-        'lock_type': 'directory' if path.endswith('/') else 'file',
-        'acquired_at': datetime.now().isoformat(),
-    })
-
-state['last_updated'] = datetime.now().isoformat()
-with open(lock_file, 'w', encoding='utf-8') as f:
-    json.dump(state, f, indent=2, ensure_ascii=False)
-PYEOF
-    log_msg "Acquired locks for $agent_id on $# paths"
-}
-
-remove_agent_locks() {
-    local agent_id="$1"
-    python3 -c "
-import json
-from datetime import datetime
-try:
-    with open('$LOCK_STATE_FILE', 'r', encoding='utf-8') as f:
-        state = json.load(f)
-    state['locks'] = [l for l in state.get('locks', []) if l.get('agent_id') != '$agent_id']
-    state['last_updated'] = datetime.now().isoformat()
-    with open('$LOCK_STATE_FILE', 'w', encoding='utf-8') as f:
-        json.dump(state, f, indent=2, ensure_ascii=False)
-except Exception:
-    pass
-" 2>/dev/null || true
-    log_msg "Released locks for $agent_id"
-}
-
-# ============================================================
-# Task Queue Operations
-# ============================================================
-
-update_task_status() {
-    local task_id="$1"
-    local status="$2"
-    local agent_id="${3:-}"
-    local branch="${4:-}"
-
-    python3 << PYEOF
-import json
-from datetime import datetime
-
-try:
-    with open('$TASK_QUEUE_FILE', 'r', encoding='utf-8') as f:
-        queue = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError):
-    exit(0)
-
-for task in queue.get('tasks', []):
-    if task['id'] == '$task_id':
-        task['status'] = '$status'
-        if '$status' == 'in_progress':
-            task['started_at'] = datetime.now().isoformat()
-            if '$agent_id':
-                task['assigned_agent'] = '$agent_id'
-            if '$branch':
-                task['branch'] = '$branch'
-            task.pop('resume_branch', None)
-        elif '$status' == 'completed':
-            task['completed_at'] = datetime.now().isoformat()
-        break
-
-queue['last_updated'] = datetime.now().isoformat()
-with open('$TASK_QUEUE_FILE', 'w', encoding='utf-8') as f:
-    json.dump(queue, f, indent=2, ensure_ascii=False)
-PYEOF
-}
-
-move_task_to_completed() {
-    local task_id="$1"
-    local tasks_dir="$WORKING_DIRECTORY/dev/pipeline/tasks"
-    local completed_dir="$WORKING_DIRECTORY/dev/pipeline/completed"
-
-    mkdir -p "$completed_dir"
-
-    # Move task file
-    for f in "$tasks_dir"/${task_id}_*.yaml "$tasks_dir"/${task_id}_*.yml "$tasks_dir"/${task_id}_*.md; do
-        if [ -f "$f" ]; then
-            mv "$f" "$completed_dir/"
-            log_msg "Moved task file to completed: $(basename "$f")"
-            break
-        fi
-    done
-
-    # Remove from TASK_QUEUE.json
-    python3 << PYEOF
-import json
-from datetime import datetime
-
-try:
-    with open('$TASK_QUEUE_FILE', 'r', encoding='utf-8') as f:
-        queue = json.load(f)
-
-    before = len(queue.get('tasks', []))
-    queue['tasks'] = [t for t in queue['tasks'] if t['id'] != '$task_id']
-    after = len(queue['tasks'])
-
-    if before != after:
-        stats = queue.get('statistics', {})
-        stats['total'] = len(queue['tasks'])
-        stats['pending'] = sum(1 for t in queue['tasks'] if t.get('status') == 'pending')
-        stats['in_progress'] = sum(1 for t in queue['tasks'] if t.get('status') == 'in_progress')
-        stats['blocked'] = sum(1 for t in queue['tasks'] if t.get('status') == 'blocked')
-        stats['completed'] = 0
-        stats['cancelled'] = sum(1 for t in queue['tasks'] if t.get('status') == 'cancelled')
-        queue['statistics'] = stats
-        queue['last_updated'] = datetime.now().isoformat()
-
-        with open('$TASK_QUEUE_FILE', 'w', encoding='utf-8') as f:
-            json.dump(queue, f, indent=2, ensure_ascii=False)
-except Exception:
-    pass
-PYEOF
-    log_msg "Removed $task_id from TASK_QUEUE.json"
-}
-
-# ============================================================
-# Progress File Update (ported from PowerShell Update-ProgressFile)
-# ============================================================
-
-update_progress_file() {
-    local task_id="$1"
-    local task_title="$2"
-    local action="$3"
-    local progress_file="$WORKING_DIRECTORY/dev/pipeline/PROGRESS.md"
-
-    [ -f "$progress_file" ] || return 0
-
-    TASK_QUEUE_FILE="$TASK_QUEUE_FILE" python3 << PYEOF "$progress_file" "$task_id" "$task_title" "$action"
-import re, os, json, sys
-from datetime import datetime
-
-progress_file = sys.argv[1]
-task_id = sys.argv[2]
-task_title = sys.argv[3]
-action = sys.argv[4]
-
-try:
-    with open(progress_file, 'r', encoding='utf-8') as f:
-        content = f.read()
-except Exception:
-    sys.exit(0)
-
-timestamp = datetime.now().strftime('%Y-%m-%d %H:%M')
-
-# Update Last Update section
-content = re.sub(r'(## Last Update\n-.*?Time.*?:)[^\n]*', rf'\1 {timestamp}', content)
-content = re.sub(r'(## Last Update\n.*?Agent.*?:)[^\n]*', r'\1 Multi-Agent Scheduler', content)
-content = re.sub(r'(## Last Update\n.*?Session.*?:)[^\n]*', rf'\1 {task_id} {action}', content)
-
-# Update statistics from current queue
-queue_file = os.environ.get('TASK_QUEUE_FILE', '')
-try:
-    with open(queue_file, 'r', encoding='utf-8') as f:
-        queue = json.load(f)
-    tasks = queue.get('tasks', [])
-    total = len(tasks)
-    completed = sum(1 for t in tasks if t.get('status') == 'completed')
-    in_progress = sum(1 for t in tasks if t.get('status') == 'in_progress')
-    pending = sum(1 for t in tasks if t.get('status') == 'pending')
-    blocked = sum(1 for t in tasks if t.get('status') == 'blocked')
-
-    # Also count completed/ directory
-    completed_dir = os.path.join(os.path.dirname(queue_file), 'completed')
-    if os.path.isdir(completed_dir):
-        completed += sum(1 for f in os.listdir(completed_dir) if re.match(r'TASK_\d+', f))
-        total += sum(1 for f in os.listdir(completed_dir) if re.match(r'TASK_\d+', f))
-
-    c_pct = round(completed / total * 100) if total > 0 else 0
-    i_pct = round(in_progress / total * 100) if total > 0 else 0
-    p_pct = round(pending / total * 100) if total > 0 else 0
-    b_pct = round(blocked / total * 100) if total > 0 else 0
-
-    stats_block = f"""Total Tasks: {total}
-Completed: {completed} ({c_pct}%)
-In Progress: {in_progress} ({i_pct}%)
-Pending: {pending} ({p_pct}%)
-Blocked: {blocked} ({b_pct}%)"""
-
-    content = re.sub(
-        r'(### Overall Progress\n```\n).*?(```)',
-        rf'\1{stats_block}\n\2',
-        content,
-        flags=re.DOTALL
-    )
-except Exception:
-    pass
-
-# Add to change history
-date_str = datetime.now().strftime('%Y-%m-%d')
-history_entry = f"| {date_str} | {action} | {task_id} - {task_title} |"
-# Insert after the header row of the history table
-content = re.sub(
-    r'(\| Date \| Action \| Details \|\n\|[-| ]+\|)\n',
-    rf'\1\n{history_entry}\n',
-    content
-)
-
-with open(progress_file, 'w', encoding='utf-8') as f:
-    f.write(content)
-PYEOF
-
-    log_msg "Updated PROGRESS.md ($task_id: $action)"
-}
-
-# Get ready tasks (pending, deps met, sorted by priority) — outputs JSON lines
-get_ready_tasks() {
-    TASK_QUEUE_FILE="$TASK_QUEUE_FILE" WORKING_DIRECTORY="$WORKING_DIRECTORY" python3 << 'PYEOF'
-import json, os, re, sys
-
-queue_file = os.environ.get('TASK_QUEUE_FILE', '')
-working_dir = os.environ.get('WORKING_DIRECTORY', '')
-
-try:
-    with open(queue_file, 'r', encoding='utf-8') as f:
-        queue = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError):
-    sys.exit(0)
-
-completed_ids = set()
-for task in queue.get('tasks', []):
-    if task.get('status') == 'completed':
-        completed_ids.add(task['id'])
-
-completed_dir = os.path.join(working_dir, 'dev/pipeline/completed')
-if os.path.isdir(completed_dir):
-    for f in os.listdir(completed_dir):
-        m = re.match(r'^(TASK_\d+)', f)
-        if m:
-            completed_ids.add(m.group(1))
-
-ready = []
-for task in queue.get('tasks', []):
-    if task.get('status') != 'pending':
-        continue
-    deps = task.get('dependencies', [])
-    if all(d in completed_ids for d in deps):
-        ready.append(task)
-
-priority_order = {'P0': 0, 'P1': 1, 'P2': 2, 'P3': 3}
-ready.sort(key=lambda t: priority_order.get(t.get('priority', 'P2'), 2))
-
-for task in ready:
-    print(json.dumps(task))
-PYEOF
-}
-
-# Check path conflict against current locks
-check_path_conflict() {
-    local scope_paths_json="$1"
-    python3 -c "
-import json, sys
-
-try:
-    with open('$LOCK_STATE_FILE', 'r', encoding='utf-8') as f:
-        state = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError):
-    print('NO_CONFLICT')
-    sys.exit(0)
-
-requested = json.loads('''$scope_paths_json''')
-locks = state.get('locks', [])
-
-for req_path in requested:
-    for lock in locks:
-        lock_path = lock.get('path', '')
-        if req_path.startswith(lock_path) or lock_path.startswith(req_path) or req_path == lock_path:
-            print(f\"CONFLICT:{lock.get('agent_id', '')}:{lock_path}:{lock.get('task_id', '')}\")
-            sys.exit(0)
-
-print('NO_CONFLICT')
-" 2>/dev/null || echo "NO_CONFLICT"
-}
-
-# ============================================================
-# Heartbeat Check
-# ============================================================
-
-check_heartbeat() {
-    if [ "$STANDALONE" = "true" ]; then
-        echo "ALIVE"
-        return
-    fi
-
-    if [ ! -f "$HEARTBEAT_FILE" ]; then
-        echo "ALIVE"
-        return
-    fi
-
-    python3 -c "
-import json, sys
-from datetime import datetime
-
-try:
-    with open('$HEARTBEAT_FILE', 'r', encoding='utf-8') as f:
-        hb = json.load(f)
-
-    if hb.get('status') == 'closing':
-        print('CLOSING')
-        sys.exit(0)
-
-    if hb.get('timestamp'):
-        ts = hb['timestamp']
-        # Handle various ISO format variants
-        for fmt in ['%Y-%m-%dT%H:%M:%S.%f', '%Y-%m-%dT%H:%M:%S', '%Y-%m-%dT%H:%M:%S%z']:
-            try:
-                last = datetime.strptime(ts.split('+')[0].split('Z')[0], fmt.replace('%z',''))
-                break
-            except ValueError:
-                continue
-        else:
-            print('ALIVE')
-            sys.exit(0)
-        elapsed = (datetime.now() - last).total_seconds()
-        if elapsed > 120:
-            print(f'TIMEOUT:{int(elapsed)}')
-            sys.exit(0)
-
-    print('ALIVE')
-except Exception:
-    print('ALIVE')
-" 2>/dev/null || echo "ALIVE"
-}
-
-# ============================================================
-# Agent Success Detection
-# ============================================================
-
-test_agent_success() {
-    local exit_code="$1"
-    local log_file="$2"
-    local branch="$3"
-    local task_id="$4"
-
-    # Exit code 0 = always success
-    if [ "$exit_code" = "0" ]; then
-        echo "SUCCESS:Exit code 0"
-        return
-    fi
-
-    # Check for commits in branch
-    if [ -n "$branch" ]; then
-        local commits_ahead="0"
-        if cd "$WORKING_DIRECTORY" 2>/dev/null; then
-            if git rev-parse --verify "$branch" >/dev/null 2>&1; then
-                local main_branch="main"
-                git rev-parse --verify main >/dev/null 2>&1 || main_branch="master"
-                commits_ahead=$(git rev-list --count "${main_branch}..${branch}" 2>/dev/null || echo "0")
-                if [ "$commits_ahead" -gt 0 ] 2>/dev/null; then
-                    local commit_msgs
-                    commit_msgs=$(git log --oneline "${main_branch}..${branch}" 2>/dev/null || echo "")
-                    if echo "$commit_msgs" | grep -q "$task_id"; then
-                        echo "SUCCESS:Branch has $commits_ahead commit(s) with $task_id"
-                        return
-                    fi
-                fi
-            fi
-        fi
-    fi
-
-    # Check log file for success patterns
-    if [ -n "$log_file" ] && [ -f "$log_file" ]; then
-        if grep -qE "Status:\s*SUCCESS|completed\s+successfully|\[SUCCESS\].*completed" "$log_file" 2>/dev/null; then
-            echo "SUCCESS:Log matches success pattern"
-            return
-        fi
-        if grep -qE "FATAL\s+ERROR|Build\s+failed|Compilation\s+error" "$log_file" 2>/dev/null; then
-            echo "FAIL:Log matches failure pattern"
-            return
-        fi
-    fi
-
-    echo "FAIL:Exit code $exit_code"
-}
-
-# ============================================================
-# Process Management
-# ============================================================
-
-kill_process_tree() {
-    local pid="$1"
-    # Try to kill the process group first
-    kill -TERM -- -"$pid" 2>/dev/null || kill -TERM "$pid" 2>/dev/null || true
-    sleep 1
-    kill -9 -- -"$pid" 2>/dev/null || kill -9 "$pid" 2>/dev/null || true
-    log_msg "Terminated process tree for PID $pid"
-}
-
-generate_agent_id() {
-    echo "agent_$(date +%H%M%S)_$(head -c 4 /dev/urandom | od -An -tx1 | tr -d ' \n' | head -c 4)"
-}
-
-# ============================================================
-# Start Agent Worker
-# ============================================================
-
-start_agent_worker() {
-    local agent_id="$1"
-    local task_id="$2"
-    local task_title="$3"
-    local agent_type="$4"
-    shift 4
-    local scope_paths_args=("$@")
-
-    local display_name
-    display_name=$(get_display_name "$agent_type")
-    log_msg "Starting $display_name ($agent_id) for task $task_id" "SUCCESS"
-
-    if [ "$DRY_RUN" = "true" ]; then
-        log_msg "[DRY RUN] Would start: claude -p '/agent-worker --task $task_id --agent $agent_id'" "WARN"
-        return 1
-    fi
-
-    # Check for resumable branch
-    local resume_branch=""
-    resume_branch=$(python3 -c "
-import json
-try:
-    with open('$TASK_QUEUE_FILE', 'r') as f:
-        q = json.load(f)
-    for t in q.get('tasks', []):
-        if t['id'] == '$task_id' and t.get('resume_branch'):
-            print(t['resume_branch'])
-            break
-except Exception:
-    pass
-" 2>/dev/null)
-
-    # Determine branch name
-    local branch_name
-    if [ -n "$resume_branch" ]; then
-        branch_name="$resume_branch"
-        log_msg "Resuming task from existing branch: $resume_branch"
-    else
-        branch_name="task-$(echo "$task_id" | tr '[:upper:]' '[:lower:]')-$agent_id"
-    fi
-
-    # Setup git branch
-    (
-        cd "$WORKING_DIRECTORY" || exit 1
-        if [ -n "$resume_branch" ]; then
-            git checkout "$resume_branch" 2>/dev/null || {
-                log_msg "Failed to checkout resume branch, creating new one" "WARN"
-                branch_name="task-$(echo "$task_id" | tr '[:upper:]' '[:lower:]')-$agent_id"
-                git checkout main 2>/dev/null || git checkout master 2>/dev/null
-                git checkout -b "$branch_name" 2>/dev/null
-            }
-        else
-            local current_branch
-            current_branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null)
-            if [ "$current_branch" != "main" ] && [ "$current_branch" != "master" ]; then
-                git checkout main 2>/dev/null || git checkout master 2>/dev/null
-            fi
-            git checkout -b "$branch_name" 2>/dev/null
-        fi
-    )
-
-    # Create agent log file
-    local agent_log="$LOG_DIR/agent_${agent_id}.log"
-    local agent_err="$LOG_DIR/agent_${agent_id}.err"
-    local prompt="/agent-worker --task $task_id --agent $agent_id --branch $branch_name"
-
-    # Launch claude agent in background (must run from project root so .claude/commands/ is found)
-    (cd "$WORKING_DIRECTORY" && exec claude --dangerously-skip-permissions -p "$prompt") \
-        > "$agent_log" 2> "$agent_err" &
-    local pid=$!
-
-    log_msg "Agent $agent_id started (PID: $pid)"
-    log_msg "Agent log: $agent_log"
-
-    # Store tracking info
-    track_agent "$agent_id" "$pid" "$task_id" "$branch_name" "$agent_type" "$agent_log" "$task_title"
-
-    return 0
-}
-
-# ============================================================
-# Backup Task Files
-# ============================================================
-
-backup_task_files() {
-    local tasks_dir="$WORKING_DIRECTORY/dev/pipeline/tasks"
-    local backup_dir="$WORKING_DIRECTORY/dev/pipeline/backups"
-
-    if [ ! -d "$tasks_dir" ]; then
-        log_msg "Tasks directory not found, skipping backup" "WARN"
-        return
-    fi
-
-    local file_count
-    file_count=$(find "$tasks_dir" -maxdepth 1 -type f 2>/dev/null | wc -l | tr -d ' ')
-    if [ "$file_count" -eq 0 ]; then
-        log_msg "No task files to backup"
-        return
-    fi
-
-    local timestamp
-    timestamp=$(date +%Y%m%d_%H%M%S)
-    local backup_path="$backup_dir/tasks_$timestamp"
-
-    mkdir -p "$backup_dir"
-    cp -r "$tasks_dir" "$backup_path"
-    log_msg "Backed up $file_count task file(s) to: $backup_path" "SUCCESS"
-
-    # Clean up old backups (keep last 5)
-    ls -dt "$backup_dir"/tasks_* 2>/dev/null | tail -n +6 | while read -r old; do
-        rm -rf "$old"
-        log_msg "Removed old backup: $(basename "$old")"
-    done
-}
-
-# ============================================================
-# Clear Stale State
-# ============================================================
-
-clear_stale_state() {
-    log_msg "Cleaning stale state from previous sessions..."
-
-    # Clear locks
-    if [ -f "$LOCK_STATE_FILE" ]; then
-        local lock_count
-        lock_count=$(python3 -c "
-import json
-try:
-    with open('$LOCK_STATE_FILE', 'r') as f:
-        data = json.load(f)
-    print(len(data.get('locks', [])))
-except Exception:
-    print(0)
-" 2>/dev/null)
-        if [ "${lock_count:-0}" -gt 0 ] 2>/dev/null; then
-            log_msg "Found $lock_count stale lock(s) from previous session" "WARN"
-        fi
-    fi
-    save_lock_state '{"locks": []}'
-
-    # Clear agents
-    if [ -f "$AGENT_STATE_FILE" ]; then
-        local agent_count
-        agent_count=$(python3 -c "
-import json
-try:
-    with open('$AGENT_STATE_FILE', 'r') as f:
-        data = json.load(f)
-    print(len(data.get('agents', [])))
-except Exception:
-    print(0)
-" 2>/dev/null)
-        if [ "${agent_count:-0}" -gt 0 ] 2>/dev/null; then
-            log_msg "Found $agent_count stale agent(s) from previous session" "WARN"
-        fi
-    fi
-    save_agent_state '{"agents": []}'
-
-    # Reset in_progress tasks to pending
-    if [ -f "$TASK_QUEUE_FILE" ]; then
-        WORKING_DIRECTORY="$WORKING_DIRECTORY" python3 << 'PYEOF'
-import json, os, subprocess
-from datetime import datetime
-
-queue_file = os.environ.get('TASK_QUEUE_FILE', '')
-working_dir = os.environ.get('WORKING_DIRECTORY', '')
-
-try:
-    with open(queue_file, 'r', encoding='utf-8') as f:
-        queue = json.load(f)
-except (FileNotFoundError, json.JSONDecodeError):
-    exit(0)
-
-changed = False
-for task in queue.get('tasks', []):
-    if task.get('status') == 'in_progress':
-        branch = task.get('branch', '')
-        has_progress = False
-
-        if branch:
-            try:
-                result = subprocess.run(
-                    ['git', 'rev-list', '--count', f'main..{branch}'],
-                    capture_output=True, text=True, cwd=working_dir
-                )
-                if result.returncode == 0 and int(result.stdout.strip()) > 0:
-                    has_progress = True
-            except Exception:
-                pass
-
-        task['status'] = 'pending'
-        task.pop('assigned_agent', None)
-        task.pop('started_at', None)
-
-        if has_progress:
-            task['resume_branch'] = branch
-            task.pop('branch', None)
-        else:
-            task.pop('branch', None)
-            task.pop('resume_branch', None)
-
-        changed = True
-
-if changed:
-    queue['last_updated'] = datetime.now().isoformat()
-    with open(queue_file, 'w', encoding='utf-8') as f:
-        json.dump(queue, f, indent=2, ensure_ascii=False)
-PYEOF
-    fi
-
-    log_msg "Stale state cleanup completed" "SUCCESS"
-}
-
-# ============================================================
-# Cleanup on Exit
-# ============================================================
-
-cleanup() {
-    log_msg "Shutting down scheduler..."
-
-    # Terminate all active agents
-    for agent_id in $(get_active_agent_ids); do
-        local pid
-        pid=$(agent_get "$agent_id" "pid")
-        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-            log_msg "Terminating agent $agent_id (PID: $pid)"
-            kill_process_tree "$pid"
-        fi
-        remove_agent_locks "$agent_id"
-        remove_agent_from_state "$agent_id"
-    done
-
-    # Update AGENT_STATE.json
-    save_agent_state '{"agents": [], "scheduler": {"status": "stopped", "stopped_at": "'"$(date -u +%Y-%m-%dT%H:%M:%S)"'"}}'
-    log_msg "Scheduler stopped"
-
-    # Cleanup tracker directory
-    rm -rf "$TRACKER_DIR"
-}
-
-trap cleanup EXIT INT TERM
-
-# ============================================================
-# Main
-# ============================================================
-
-clear
-echo ""
-echo "============================================================"
-echo "       Multi-Agent Parallel Scheduler"
-echo "============================================================"
-echo "  Max Parallel Agents: $MAX_AGENTS"
-echo "  Poll Interval: ${POLL_INTERVAL}s"
-echo "  Task Timeout: ${TASK_TIMEOUT}min"
-echo "  Working Dir: $WORKING_DIRECTORY"
-[ "$DRY_RUN" = "true" ] && echo "  Mode: DRY RUN"
-[ "$STANDALONE" = "true" ] && echo "  Mode: STANDALONE (heartbeat ignored)"
-echo "============================================================"
-echo ""
-
-# Write startup debug log
-cat > "$STARTUP_LOG" << EOF
-=== Multi-Agent Scheduler Startup ===
-Time: $(date "+%Y-%m-%d %H:%M:%S")
-WorkingDirectory: $WORKING_DIRECTORY
-Script Directory: $SCRIPT_DIR
-Shell: ${SHELL:-bash}
-OS: $(uname -s) $(uname -r)
-Standalone: $STANDALONE
-MaxAgents: $MAX_AGENTS
-PollIntervalSeconds: $POLL_INTERVAL
-TaskTimeoutMinutes: $TASK_TIMEOUT
-=== Execution Log ===
-EOF
-
-# --- Prerequisite Checks ---
-echo "[CHECK] Running prerequisite checks..."
-
-if ! command -v claude >/dev/null 2>&1; then
-    echo ""
-    echo "============================================================"
-    echo "  ERROR: Claude CLI not found!"
-    echo "============================================================"
-    echo ""
-    echo "  To install:"
-    echo "    npm install -g @anthropic-ai/claude-code"
-    echo ""
-    exit 1
-fi
-echo "  [OK] Claude CLI found"
-
-if ! command -v python3 >/dev/null 2>&1; then
-    echo "  [ERROR] python3 not found (required for JSON operations)"
-    exit 1
-fi
-echo "  [OK] python3 found"
-
-if [ ! -d "$WORKING_DIRECTORY" ]; then
-    echo "  [ERROR] Working directory not found: $WORKING_DIRECTORY"
-    exit 1
-fi
-echo "  [OK] Working directory exists"
-
-if [ ! -d "$WORKING_DIRECTORY/dev/pipeline" ]; then
-    echo "  [ERROR] Pipeline directory not found. Run Initialize Project first."
-    exit 1
-fi
-echo "  [OK] Pipeline directory exists"
-
-if [ ! -f "$TASK_QUEUE_FILE" ]; then
-    echo "  [WARN] Task queue not found, will be created by sync"
-fi
-
-echo "[CHECK] Prerequisites passed"
-echo ""
-
-# --- Standalone: remove old heartbeat ---
-if [ "$STANDALONE" = "true" ] && [ -f "$HEARTBEAT_FILE" ]; then
-    rm -f "$HEARTBEAT_FILE"
-    echo "[STANDALONE] Removed old heartbeat file"
-fi
-
-# --- Auto-sync task queue ---
-echo "[SYNC] Syncing task queue from task files..."
-SYNC_SCRIPT="$SCRIPT_DIR/sync_task_queue.sh"
-if [ -x "$SYNC_SCRIPT" ]; then
-    "$SYNC_SCRIPT" --wd "$WORKING_DIRECTORY" --quiet || true
-    echo "[SYNC] Task queue synced successfully"
-else
-    echo "[SYNC] sync_task_queue.sh not found or not executable, skipping"
-fi
-echo ""
-
-log_msg "Multi-Agent Scheduler started (MaxAgents=$MAX_AGENTS)"
-
-# Backup task files
-backup_task_files
-
-# Clean stale state
-export TASK_QUEUE_FILE WORKING_DIRECTORY
-clear_stale_state
-
-# Check for pending tasks
-PENDING_INFO=$(python3 -c "
-import json
-try:
-    with open('$TASK_QUEUE_FILE', 'r') as f:
-        q = json.load(f)
-    pending = [t for t in q.get('tasks', []) if t.get('status') == 'pending']
-    total = len(q.get('tasks', []))
-    print(f'{len(pending)}:{total}')
-except Exception:
-    print('0:0')
-" 2>/dev/null)
-
-PENDING="${PENDING_INFO%%:*}"
-TOTAL="${PENDING_INFO##*:}"
-
-if [ "$PENDING" -eq 0 ] 2>/dev/null; then
-    echo ""
-    echo "============================================================"
-    echo "  No pending tasks found!"
-    echo "============================================================"
-    echo "  Total: $TOTAL  Pending: 0"
-    echo ""
-    if [ "$SINGLE_RUN" = "true" ]; then
-        log_msg "No pending tasks (SingleRun mode)"
-        exit 0
-    fi
-    log_msg "No pending tasks. Scheduler will wait for new tasks..."
-else
-    log_msg "Found $PENDING pending task(s) out of $TOTAL total" "SUCCESS"
-fi
-
-# Set scheduler status to running
-save_agent_state '{"agents": [], "scheduler": {"status": "running", "max_agents": '"$MAX_AGENTS"', "started_at": "'"$(date -u +%Y-%m-%dT%H:%M:%S)"'"}}'
-log_msg "Scheduler status set to 'running' in AGENT_STATE.json"
-
-# Sync counter
-SYNC_COUNTER=0
-SYNC_INTERVAL=5
-
-# ============================================================
-# Main Loop
-# ============================================================
-
-while true; do
-    # Check if scheduler was stopped via API
-    local_status=$(python3 -c "
-import json
-try:
-    with open('$AGENT_STATE_FILE', 'r') as f:
-        s = json.load(f)
-    print(s.get('scheduler', {}).get('status', 'running'))
-except Exception:
-    print('running')
-" 2>/dev/null)
-
-    if [ "$local_status" = "stopped" ]; then
-        log_msg "Scheduler stop requested via API - shutting down..." "WARN"
-        exit 0
-    fi
-
-    # Check heartbeat
-    hb_status=$(check_heartbeat)
-    if [ "$hb_status" = "CLOSING" ]; then
-        log_msg "Dashboard explicitly closed. Exiting." "WARN"
-        exit 0
-    fi
-    case "$hb_status" in
-        TIMEOUT:*)
-            log_msg "Dashboard heartbeat timeout. Exiting." "WARN"
-            exit 0
-            ;;
-    esac
-
-    # Periodic sync
-    SYNC_COUNTER=$((SYNC_COUNTER + 1))
-    active_count=$(get_active_count)
-    if [ $SYNC_COUNTER -ge $SYNC_INTERVAL ] || [ "$active_count" -eq 0 ]; then
-        SYNC_COUNTER=0
-        if [ -x "$SYNC_SCRIPT" ]; then
-            "$SYNC_SCRIPT" --wd "$WORKING_DIRECTORY" --quiet 2>/dev/null || true
-        fi
-    fi
-
-    # Check completed agents
-    for agent_id in $(get_active_agent_ids); do
-        pid=$(agent_get "$agent_id" "pid")
-        task_id=$(agent_get "$agent_id" "task_id")
-        branch=$(agent_get "$agent_id" "branch")
-        start_time=$(agent_get "$agent_id" "start_time")
-        agent_log=$(agent_get "$agent_id" "log_file")
-
-        if [ -z "$pid" ]; then
-            untrack_agent "$agent_id"
-            continue
-        fi
-
-        if ! kill -0 "$pid" 2>/dev/null; then
-            # Process has exited
-            wait "$pid" 2>/dev/null
-            exit_code=$?
-            now=$(date +%s)
-            duration_min=$(( (now - start_time) / 60 ))
-
-            result=$(test_agent_success "$exit_code" "$agent_log" "$branch" "$task_id")
-
-            case "$result" in
-                SUCCESS:*)
-                    reason="${result#SUCCESS:}"
-                    log_msg "Agent $agent_id completed task $task_id successfully (${duration_min}min) - $reason" "SUCCESS"
-
-                    # Get task title before moving (from tracker)
-                    task_title=$(agent_get "$agent_id" "task_title")
-
-                    update_task_status "$task_id" "completed"
-                    move_task_to_completed "$task_id"
-
-                    # Update PROGRESS.md
-                    update_progress_file "$task_id" "$task_title" "Completed"
-
-                    # Merge branch to main
-                    (
-                        cd "$WORKING_DIRECTORY" || exit 1
-                        git checkout main 2>/dev/null || git checkout master 2>/dev/null
-                        git merge "$branch" -m "Merge $task_id: Completed by $agent_id" 2>/dev/null || true
-                        git branch -d "$branch" 2>/dev/null || true
-                    ) && log_msg "Merged branch $branch to main" "SUCCESS"
-                    ;;
-                *)
-                    reason="${result#FAIL:}"
-                    log_msg "Agent $agent_id failed task $task_id after ${duration_min}min - $reason" "ERROR"
-
-                    # Check for partial work
-                    has_partial=false
-                    if [ -n "$branch" ]; then
-                        partial_check=$(
-                            cd "$WORKING_DIRECTORY" 2>/dev/null || exit 0
-                            if git rev-parse --verify "$branch" >/dev/null 2>&1; then
-                                main_branch="main"
-                                git rev-parse --verify main >/dev/null 2>&1 || main_branch="master"
-                                ahead=$(git rev-list --count "${main_branch}..${branch}" 2>/dev/null || echo "0")
-                                [ "$ahead" -gt 0 ] 2>/dev/null && echo "PARTIAL"
-                            fi
-                        )
-                        [ "$partial_check" = "PARTIAL" ] && has_partial=true
-                    fi
-
-                    if [ "$has_partial" = "true" ]; then
-                        log_msg "Branch $branch has commits - marking for resume"
-                        python3 -c "
-import json
-from datetime import datetime
-try:
-    with open('$TASK_QUEUE_FILE', 'r') as f:
-        q = json.load(f)
-    for t in q.get('tasks', []):
-        if t['id'] == '$task_id':
-            t['status'] = 'pending'
-            t['resume_branch'] = '$branch'
-            t.pop('assigned_agent', None)
-            break
-    q['last_updated'] = datetime.now().isoformat()
-    with open('$TASK_QUEUE_FILE', 'w') as f:
-        json.dump(q, f, indent=2, ensure_ascii=False)
-except Exception:
-    pass
-" 2>/dev/null
-                    else
-                        update_task_status "$task_id" "pending"
-                    fi
-                    ;;
-            esac
-
-            remove_agent_locks "$agent_id"
-            remove_agent_from_state "$agent_id"
-            untrack_agent "$agent_id"
-        else
-            # Check timeout
-            now=$(date +%s)
-            elapsed_min=$(( (now - start_time) / 60 ))
-            if [ $elapsed_min -gt $TASK_TIMEOUT ] 2>/dev/null; then
-                log_msg "Agent $agent_id timed out on task $task_id (PID: $pid)" "WARN"
-                kill_process_tree "$pid"
-                remove_agent_locks "$agent_id"
-                remove_agent_from_state "$agent_id"
-                update_task_status "$task_id" "pending"
-                untrack_agent "$agent_id"
-            fi
-        fi
-    done
-
-    # Start new agents if slots available
-    active_count=$(get_active_count)
-    available_slots=$(( MAX_AGENTS - active_count ))
-
-    if [ $available_slots -gt 0 ]; then
-        get_ready_tasks | while IFS= read -r task_json; do
-            [ -z "$task_json" ] && continue
-
-            # Re-check available slots (may have changed in this loop iteration)
-            current_active=$(get_active_count)
-            current_available=$(( MAX_AGENTS - current_active ))
-            [ $current_available -le 0 ] && break
-
-            task_id=$(echo "$task_json" | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])")
-            task_title=$(echo "$task_json" | python3 -c "import sys,json; print(json.load(sys.stdin)['title'])")
-            scope_paths_json=$(echo "$task_json" | python3 -c "import sys,json; t=json.load(sys.stdin); print(json.dumps(t.get('scope_paths', t.get('scope', {}).get('paths', ['src/']))))")
-            agent_type_explicit=$(echo "$task_json" | python3 -c "import sys,json; print(json.load(sys.stdin).get('agent_type', ''))")
-
-            # Skip already running tasks
-            if is_task_running "$task_id"; then
-                continue
-            fi
-
-            # Check path conflict
-            conflict_result=$(check_path_conflict "$scope_paths_json")
-            if [ "$conflict_result" != "NO_CONFLICT" ]; then
-                conflict_info="${conflict_result#CONFLICT:}"
-                log_msg "Task $task_id conflicts with $conflict_info" "WARN"
-                continue
-            fi
-
-            # Read scope paths into args
-            scope_paths_args=()
-            while IFS= read -r p; do
-                scope_paths_args+=("$p")
-            done < <(echo "$scope_paths_json" | python3 -c "import sys,json; [print(p) for p in json.load(sys.stdin)]")
-
-            # Determine agent type
-            agent_type=$(get_agent_type "$task_title" "$agent_type_explicit")
-
-            # Generate agent ID
-            agent_id=$(generate_agent_id)
-
-            # Start agent
-            if start_agent_worker "$agent_id" "$task_id" "$task_title" "$agent_type" "${scope_paths_args[@]}"; then
-                branch=$(agent_get "$agent_id" "branch")
-
-                # Add locks
-                add_path_locks "$agent_id" "$task_id" "${scope_paths_args[@]}"
-
-                # Update task status
-                update_task_status "$task_id" "in_progress" "$agent_id" "$branch"
-
-                # Update AGENT_STATE.json
-                add_agent_to_state "$agent_id" "$task_id" "$task_title" "$branch" "$agent_type"
-
-                display_name=$(get_display_name "$agent_type")
-                log_msg "Launched $display_name ($agent_id) for $task_id: $task_title"
-            fi
-        done
-    fi
-
-    # Display status line
-    timestamp=$(date "+%H:%M:%S")
-    active_count=$(get_active_count)
-    status_line="[$timestamp] Agents: ${active_count}/$MAX_AGENTS"
-
-    if [ "$active_count" -gt 0 ]; then
-        agent_info=""
-        for agent_id in $(get_active_agent_ids); do
-            start_time=$(agent_get "$agent_id" "start_time")
-            task_id=$(agent_get "$agent_id" "task_id")
-            now=$(date +%s)
-            elapsed_min=$(( (now - start_time) / 60 ))
-            agent_info="$agent_info ${task_id}(${elapsed_min}min)"
-        done
-        status_line="$status_line |$agent_info"
-    else
-        status_line="$status_line | Waiting for tasks..."
-    fi
-    printf '\033[36m%s\033[0m\n' "$status_line"
-
-    # Single run check
-    if [ "$SINGLE_RUN" = "true" ] && [ "$active_count" -eq 0 ]; then
-        log_msg "Single run completed, no active agents"
-        break
-    fi
-
-    sleep "$POLL_INTERVAL"
-done