@open-agent-toolkit/cli 0.0.42 → 0.0.50

package/assets/skills/oat-project-subagent-implement/examples/pattern-parallel-phases.md

@@ -1,118 +0,0 @@
-# Usage Pattern: Simple Parallel Phases
-
-Two independent phases execute in parallel, then merge cleanly.
-
-## Plan Excerpt
-
-```yaml
----
-oat_plan_hill_phases: ['p03']
----
-```
-
-```markdown
-## Phase 1: API Endpoints
-
-### Task p01-t01: Create user endpoint
-
-**Files:**
-
-- Create: `src/routes/user.ts`
-- Create: `src/routes/user.test.ts`
-
-### Task p01-t02: Create settings endpoint
-
-**Files:**
-
-- Create: `src/routes/settings.ts`
-- Create: `src/routes/settings.test.ts`
-
-## Phase 2: UI Components
-
-### Task p02-t01: Create user profile component
-
-**Files:**
-
-- Create: `src/components/UserProfile.tsx`
-- Create: `src/components/UserProfile.test.tsx`
-
-### Task p02-t02: Create settings panel component
-
-**Files:**
-
-- Create: `src/components/SettingsPanel.tsx`
-- Create: `src/components/SettingsPanel.test.tsx`
-
-## Phase 3: Integration
-
-### Task p03-t01: Wire API to UI
-
-**Files:**
-
-- Modify: `src/routes/user.ts`
-- Modify: `src/components/UserProfile.tsx`
-```
-
-## Orchestration Flow
-
-1. **Dispatch manifest** identifies p01 and p02 as parallel-safe (no overlapping files).
-2. **Bootstrap** creates two worktrees:
-   - `project-name/p01` (branch from orchestration base)
-   - `project-name/p02` (branch from orchestration base)
-3. **Subagents** execute concurrently:
-   - Subagent A: implements p01-t01 and p01-t02 in worktree p01
-   - Subagent B: implements p02-t01 and p02-t02 in worktree p02
-4. **Review gate** runs per unit:
-   - p01: spec compliance (pass) -> code quality (pass) -> eligible for merge
-   - p02: spec compliance (pass) -> code quality (pass) -> eligible for merge
-5. **Reconciliation** merges in deterministic order:
-   - Merge p01 (order 1) -> integration verification passes
-   - Merge p02 (order 2) -> integration verification passes
-6. **HiLL checkpoint** at p03: orchestrator pauses, reports progress, waits for user.
-7. After user approval, p03 executes sequentially (it modifies files from both p01 and p02).
-
-## Expected Artifact Output
-
-In `implementation.md` under `## Orchestration Runs`:
-
-```markdown
-### Run 1 — 2026-02-17 14:30
-
-**Branch:** autonomous-orchestration-impl
-**Policy:** baseline=strict, merge=merge, retry-limit=2
-**Units:** 2 dispatched, 2 passed, 0 failed, 0 conflicts
-
-#### Unit Outcomes
-
-| Unit | Status | Commits | Tests | Review | Disposition |
-| ---- | ------ | ------- | ----- | ------ | ----------- |
-| p01  | pass   | abc1234 | pass  | pass   | merged      |
-| p02  | pass   | def5678 | pass  | pass   | merged      |
-
-#### Review Interaction Log
-
-**p01:**
-
-- **Spec compliance:** pass (0 findings)
-- **Code quality:** pass (0 findings)
-- **Verdict:** pass
-- **Disposition:** merged
-
-**p02:**
-
-- **Spec compliance:** pass (0 findings)
-- **Code quality:** pass (0 findings)
-- **Verdict:** pass
-- **Disposition:** merged
-
-#### Merge Outcomes
-
-| Order | Unit | Strategy | Result | Integration |
-| ----- | ---- | -------- | ------ | ----------- |
-| 1     | p01  | merge    | clean  | tests pass  |
-| 2     | p02  | merge    | clean  | tests pass  |
-
-#### Outstanding Items
-
-- None
-```

package/assets/skills/oat-project-subagent-implement/scripts/dispatch.sh

@@ -1,133 +0,0 @@
-#!/usr/bin/env bash
-# oat-project-subagent-implement: Fan-out dispatch and result collection
-#
-# Usage: dispatch.sh <plan-path> <project-path> <orchestration-branch> [--unit-granularity <phase|task>]
-#
-# This script is a reference implementation for the orchestrator agent.
-# It parses the plan, identifies parallelizable units, and outputs
-# a dispatch manifest for the orchestrator to execute via the Task tool.
-#
-# The orchestrator reads the manifest and dispatches subagents accordingly.
-# This script does NOT dispatch subagents directly — that requires the
-# Task tool, which is only available to the agent runtime.
-
-set -euo pipefail
-
-# ─── Defaults ───────────────────────────────────────────────────────────────
-PLAN_PATH=""
-PROJECT_PATH=""
-ORCHESTRATION_BRANCH=""
-UNIT_GRANULARITY="phase"
-
-# ─── Parse Arguments ────────────────────────────────────────────────────────
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --unit-granularity) UNIT_GRANULARITY="$2"; shift 2 ;;
-    -*)                 echo "error: unknown flag $1" >&2; exit 1 ;;
-    *)
-      if [[ -z "$PLAN_PATH" ]]; then PLAN_PATH="$1"
-      elif [[ -z "$PROJECT_PATH" ]]; then PROJECT_PATH="$1"
-      elif [[ -z "$ORCHESTRATION_BRANCH" ]]; then ORCHESTRATION_BRANCH="$1"
-      fi
-      shift
-      ;;
-  esac
-done
-
-if [[ -z "$PLAN_PATH" || -z "$PROJECT_PATH" || -z "$ORCHESTRATION_BRANCH" ]]; then
-  echo "error: required: <plan-path> <project-path> <orchestration-branch>" >&2
-  exit 1
-fi
-
-# ─── Step 1: Parse Plan Structure ───────────────────────────────────────────
-# Extract phase and task structure from plan.md
-# Output: list of units with task IDs, files, and verification commands
-
-echo "--- dispatch_manifest ---"
-echo "orchestration_branch: $ORCHESTRATION_BRANCH"
-echo "unit_granularity: $UNIT_GRANULARITY"
-echo "plan_path: $PLAN_PATH"
-echo "project_path: $PROJECT_PATH"
-echo "log_path: $PROJECT_PATH/implementation.md"
-echo "units:"
-
-# Parse phases (## Phase N: ...)
-CURRENT_PHASE=""
-CURRENT_TASK=""
-TASK_FILES=""
-IN_FILES_BLOCK=false
-
-while IFS= read -r line; do
-  # Detect phase headers
-  if [[ "$line" =~ ^##\ Phase\ ([0-9]+):\ (.+)$ ]]; then
-    CURRENT_PHASE="p$(printf '%02d' "${BASH_REMATCH[1]}")"
-    PHASE_NAME="${BASH_REMATCH[2]}"
-
-    if [[ "$UNIT_GRANULARITY" == "phase" ]]; then
-      echo "  - unit_id: \"$CURRENT_PHASE\""
-      echo "    phase: \"$CURRENT_PHASE\""
-      echo "    phase_name: \"$PHASE_NAME\""
-      echo "    type: phase"
-      echo "    tasks:"
-    fi
-  fi
-
-  # Detect task headers (### Task pNN-tNN: ...)
-  if [[ "$line" =~ ^###\ Task\ (p[0-9]+-t[0-9]+):\ (.+)$ ]]; then
-    CURRENT_TASK="${BASH_REMATCH[1]}"
-    TASK_NAME="${BASH_REMATCH[2]}"
-
-    if [[ "$UNIT_GRANULARITY" == "task" ]]; then
-      echo "  - unit_id: \"$CURRENT_TASK\""
-      echo "    phase: \"$CURRENT_PHASE\""
-      echo "    task_id: \"$CURRENT_TASK\""
-      echo "    task_name: \"$TASK_NAME\""
-      echo "    type: task"
-    elif [[ "$UNIT_GRANULARITY" == "phase" ]]; then
-      # Append task to current phase unit
-      echo "      - \"$CURRENT_TASK\""
-    fi
-  fi
-
-  # Detect file boundaries
-  if [[ "$line" =~ ^\*\*Files:\*\*$ ]]; then
-    IN_FILES_BLOCK=true
-    if [[ "$UNIT_GRANULARITY" == "task" ]]; then
-      echo "    files:"
-    fi
-  elif [[ "$IN_FILES_BLOCK" == true ]]; then
-    if [[ "$line" =~ ^-\ (Create|Modify):\ \`(.+)\`$ ]]; then
-      if [[ "$UNIT_GRANULARITY" == "task" ]]; then
-        echo "      - action: \"${BASH_REMATCH[1]}\""
-        echo "        path: \"${BASH_REMATCH[2]}\""
-      fi
-    elif [[ ! "$line" =~ ^- ]]; then
-      IN_FILES_BLOCK=false
-    fi
-  fi
-done < "$PLAN_PATH"
-
-echo "---"
-
-# ─── Step 2: Check HiLL Checkpoints ─────────────────────────────────────────
-# Extract oat_plan_hill_phases from frontmatter
-HIL_PHASES=$(sed -n '/^---$/,/^---$/p' "$PLAN_PATH" | grep 'oat_plan_hill_phases' | sed 's/.*: //' || true)
-echo "hill_checkpoints: $HIL_PHASES"
-
-# ─── Step 3: Output Branch Naming Plan ──────────────────────────────────────
-PROJECT_NAME=$(basename "$PROJECT_PATH")
-echo "branch_naming:"
-echo "  pattern: \"${PROJECT_NAME}/{unit-id}\""
-echo "  base_ref: \"$ORCHESTRATION_BRANCH\""
-echo "  examples:"
-
-# Re-parse to list branch names
-while IFS= read -r line; do
-  if [[ "$UNIT_GRANULARITY" == "phase" && "$line" =~ ^##\ Phase\ ([0-9]+): ]]; then
-    PHASE_ID="p$(printf '%02d' "${BASH_REMATCH[1]}")"
-    echo "    - \"${PROJECT_NAME}/${PHASE_ID}\""
-  elif [[ "$UNIT_GRANULARITY" == "task" && "$line" =~ ^###\ Task\ (p[0-9]+-t[0-9]+): ]]; then
-    TASK_ID="${BASH_REMATCH[1]}"
-    echo "    - \"${PROJECT_NAME}/${TASK_ID}\""
-  fi
-done < "$PLAN_PATH"

package/assets/skills/oat-project-subagent-implement/scripts/reconcile.sh

@@ -1,182 +0,0 @@
-#!/usr/bin/env bash
-# oat-project-subagent-implement: Fan-in merge/reconcile logic
-#
-# Usage: reconcile.sh <orchestration-branch> [--merge-strategy <merge|cherry-pick>] <unit-branch>...
-#
-# This script merges passing unit branches back into the orchestration
-# branch in deterministic order (by task ID) with integration verification
-# after each merge.
-#
-# If merge fails, falls back to cherry-pick. If both fail, classifies
-# the conflict and reports for manual resolution.
-
-set -euo pipefail
-
-# ─── Defaults ───────────────────────────────────────────────────────────────
-ORCHESTRATION_BRANCH=""
-MERGE_STRATEGY="merge"
-UNIT_BRANCHES=()
-
-# ─── Parse Arguments ────────────────────────────────────────────────────────
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --merge-strategy) MERGE_STRATEGY="$2"; shift 2 ;;
-    -*)               echo "error: unknown flag $1" >&2; exit 1 ;;
-    *)
-      if [[ -z "$ORCHESTRATION_BRANCH" ]]; then
-        ORCHESTRATION_BRANCH="$1"
-      else
-        UNIT_BRANCHES+=("$1")
-      fi
-      shift
-      ;;
-  esac
-done
-
-if [[ -z "$ORCHESTRATION_BRANCH" || ${#UNIT_BRANCHES[@]} -eq 0 ]]; then
-  echo "error: required: <orchestration-branch> <unit-branch>..." >&2
-  exit 1
-fi
-
-# ─── Sort Branches by Task ID ──────────────────────────────────────────────
-# Deterministic ordering: sort by the unit ID suffix (p01-t01, p02-t01, etc.)
-IFS=$'\n' SORTED_BRANCHES=($(printf '%s\n' "${UNIT_BRANCHES[@]}" | sort)); unset IFS
-
-# ─── Checkout Orchestration Branch ──────────────────────────────────────────
-git checkout "$ORCHESTRATION_BRANCH"
-
-echo "--- reconcile_manifest ---"
-echo "orchestration_branch: $ORCHESTRATION_BRANCH"
-echo "merge_strategy: $MERGE_STRATEGY"
-echo "unit_count: ${#SORTED_BRANCHES[@]}"
-echo "merge_outcomes:"
-
-MERGE_ORDER=0
-TOTAL_MERGED=0
-TOTAL_CONFLICTS=0
-TOTAL_REVERTED=0
-TOTAL_NO_COMMITS=0
-
-for UNIT_BRANCH in "${SORTED_BRANCHES[@]}"; do
-  MERGE_ORDER=$((MERGE_ORDER + 1))
-  UNIT_ID=$(echo "$UNIT_BRANCH" | sed 's|.*/||')  # Extract unit ID from branch name
-
-  echo "  - order: $MERGE_ORDER"
-  echo "    unit_id: \"$UNIT_ID\""
-  echo "    branch: \"$UNIT_BRANCH\""
-
-  # ─── Attempt Merge ────────────────────────────────────────────────────
-  STRATEGY_USED="$MERGE_STRATEGY"
-  MERGE_RESULT="pending"
-  PRE_MERGE_SHA=$(git rev-parse HEAD)
-
-  if [[ "$MERGE_STRATEGY" == "merge" ]]; then
-    if git merge --no-ff "$UNIT_BRANCH" -m "merge($UNIT_ID): reconcile unit into orchestration branch" 2>/dev/null; then
-      MERGE_RESULT="clean"
-    else
-      # Merge conflict — abort and try cherry-pick fallback
-      git merge --abort 2>/dev/null || true
-      STRATEGY_USED="cherry-pick (fallback)"
-
-      # Get commits unique to the unit branch
-      COMMITS=$(git log --reverse --format='%H' "$ORCHESTRATION_BRANCH..$UNIT_BRANCH" 2>/dev/null || true)
-      if [[ -n "$COMMITS" ]]; then
-        CHERRY_FAILED=false
-        while IFS= read -r COMMIT; do
-          if ! git cherry-pick "$COMMIT" 2>/dev/null; then
-            git cherry-pick --abort 2>/dev/null || true
-            CHERRY_FAILED=true
-            break
-          fi
-        done <<< "$COMMITS"
-
-        if [[ "$CHERRY_FAILED" == true ]]; then
-          MERGE_RESULT="conflict"
-        else
-          MERGE_RESULT="clean"
-        fi
-      else
-        MERGE_RESULT="no_commits"
-      fi
-    fi
-  elif [[ "$MERGE_STRATEGY" == "cherry-pick" ]]; then
-    COMMITS=$(git log --reverse --format='%H' "$ORCHESTRATION_BRANCH..$UNIT_BRANCH" 2>/dev/null || true)
-    if [[ -n "$COMMITS" ]]; then
-      CHERRY_FAILED=false
-      while IFS= read -r COMMIT; do
-        if ! git cherry-pick "$COMMIT" 2>/dev/null; then
-          git cherry-pick --abort 2>/dev/null || true
-          CHERRY_FAILED=true
-          break
-        fi
-      done <<< "$COMMITS"
-
-      if [[ "$CHERRY_FAILED" == true ]]; then
-        MERGE_RESULT="conflict"
-      else
-        MERGE_RESULT="clean"
-      fi
-    else
-      MERGE_RESULT="no_commits"
-    fi
-  fi
-
-  echo "    strategy: \"$STRATEGY_USED\""
-
-  # ─── Integration Verification ─────────────────────────────────────────
-  if [[ "$MERGE_RESULT" == "clean" ]]; then
-    INTEGRATION="pending"
-
-    # Run integration checks
-    TESTS_PASS=true
-    LINT_PASS=true
-    TYPECHECK_PASS=true
-
-    pnpm test >/dev/null 2>&1 || TESTS_PASS=false
-    pnpm lint >/dev/null 2>&1 || LINT_PASS=false
-    pnpm type-check >/dev/null 2>&1 || TYPECHECK_PASS=false
-
-    if [[ "$TESTS_PASS" == true && "$LINT_PASS" == true && "$TYPECHECK_PASS" == true ]]; then
-      INTEGRATION="pass"
-      TOTAL_MERGED=$((TOTAL_MERGED + 1))
-    else
-      INTEGRATION="fail"
-      # Rollback to pre-merge state
-      git reset --hard "$PRE_MERGE_SHA" 2>/dev/null || true
-      MERGE_RESULT="reverted"
-      TOTAL_REVERTED=$((TOTAL_REVERTED + 1))
-    fi
-
-    echo "    result: $MERGE_RESULT"
-    echo "    integration:"
-    echo "      tests: $([ "$TESTS_PASS" == true ] && echo 'pass' || echo 'fail')"
-    echo "      lint: $([ "$LINT_PASS" == true ] && echo 'pass' || echo 'fail')"
-    echo "      type_check: $([ "$TYPECHECK_PASS" == true ] && echo 'pass' || echo 'fail')"
-    echo "      verdict: $INTEGRATION"
-  else
-    echo "    result: $MERGE_RESULT"
-    if [[ "$MERGE_RESULT" == "conflict" ]]; then
-      TOTAL_CONFLICTS=$((TOTAL_CONFLICTS + 1))
-    elif [[ "$MERGE_RESULT" == "no_commits" ]]; then
-      TOTAL_NO_COMMITS=$((TOTAL_NO_COMMITS + 1))
-    fi
-    echo "    integration: skipped (merge not clean)"
-
-    # Classify conflict
-    if [[ "$MERGE_RESULT" == "conflict" ]]; then
-      echo "    conflict_type: file-level"
-      echo "    resolution: manual_required"
-    fi
-  fi
-done
-
-# ─── Summary ────────────────────────────────────────────────────────────────
-echo "summary:"
-echo "  total_units: ${#SORTED_BRANCHES[@]}"
-echo "  merged: $TOTAL_MERGED"
-echo "  conflicts: $TOTAL_CONFLICTS"
-echo "  reverted: $TOTAL_REVERTED"
-echo "  no_commits: $TOTAL_NO_COMMITS"
-echo "  final_branch: $ORCHESTRATION_BRANCH"
-echo "  final_commit: $(git rev-parse HEAD 2>/dev/null || echo 'unknown')"
-echo "---"

package/assets/skills/oat-project-subagent-implement/scripts/review-gate.sh

@@ -1,187 +0,0 @@
-#!/usr/bin/env bash
-# oat-project-subagent-implement: Autonomous review gate with fix-loop retry
-#
-# Usage: review-gate.sh <unit-branch> <worktree-path> [--retry-limit <N>]
-#
-# This script is a reference implementation for the review gate logic.
-# The orchestrator agent uses it (or follows its logic) to run the
-# two-stage review gate per unit after subagent implementation.
-#
-# Stage 1: Spec compliance (does the implementation match the plan?)
-# Stage 2: Code quality (is the code well-written and passing checks?)
-#
-# If a stage fails, the fix-loop dispatches the implementer to fix,
-# then re-runs the same stage. Up to --retry-limit attempts.
-
-set -euo pipefail
-
-# ─── Defaults ───────────────────────────────────────────────────────────────
-UNIT_BRANCH=""
-WORKTREE_PATH=""
-RETRY_LIMIT=2
-RETRY_COUNT=0
-
-# ─── Parse Arguments ────────────────────────────────────────────────────────
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --retry-limit) RETRY_LIMIT="$2"; shift 2 ;;
-    --retry-count) RETRY_COUNT="$2"; shift 2 ;;
-    -*)            echo "error: unknown flag $1" >&2; exit 1 ;;
-    *)
-      if [[ -z "$UNIT_BRANCH" ]]; then UNIT_BRANCH="$1"
-      elif [[ -z "$WORKTREE_PATH" ]]; then WORKTREE_PATH="$1"
-      fi
-      shift
-      ;;
-  esac
-done
-
-if [[ -z "$UNIT_BRANCH" || -z "$WORKTREE_PATH" ]]; then
-  echo "error: required: <unit-branch> <worktree-path>" >&2
-  exit 1
-fi
-
-cd "$WORKTREE_PATH"
-
-# ─── Stage 1: Spec Compliance ──────────────────────────────────────────────
-# The orchestrator agent runs this check by comparing the implementer's
-# output against the plan task specification.
-#
-# Checks:
-# 1. All planned files exist (created/modified as specified)
-# 2. Verification commands from plan pass
-# 3. No files modified outside the task's file boundary
-# 4. No scope creep (features not in the plan)
-#
-# This stage is primarily agent-driven (reading code vs spec).
-# The shell checks below handle the automatable parts.
-
-echo "--- review_gate ---"
-echo "unit_branch: $UNIT_BRANCH"
-echo "worktree_path: $WORKTREE_PATH"
-echo "retry_limit: $RETRY_LIMIT"
-
-SPEC_VERDICT="pass"
-QUALITY_VERDICT="pending"
-FINDINGS_CRITICAL=()
-FINDINGS_IMPORTANT=()
-FINDINGS_MINOR=()
-
-# Automatable spec checks: verification commands
-echo "stage: spec_compliance"
-echo "checks:"
-
-# Check: tests pass
-if pnpm test >/dev/null 2>&1; then
-  echo "  tests: pass"
-else
-  echo "  tests: fail"
-  SPEC_VERDICT="fail"
-  FINDINGS_CRITICAL+=("Tests failing in unit branch")
-fi
-
-# Check: git status is clean (all work committed)
-if [[ -z "$(git status --porcelain)" ]]; then
-  echo "  git_clean: pass"
-else
-  echo "  git_clean: fail"
-  SPEC_VERDICT="fail"
-  FINDINGS_IMPORTANT+=("Uncommitted changes in unit branch")
-fi
-
-echo "  spec_verdict: $SPEC_VERDICT"
-
-# ─── Stage 2: Code Quality ─────────────────────────────────────────────────
-# Only runs if spec compliance passes.
-
-if [[ "$SPEC_VERDICT" == "pass" ]]; then
-  echo "stage: code_quality"
-  echo "checks:"
-  QUALITY_VERDICT="pass"
-
-  # Check: lint
-  if pnpm lint >/dev/null 2>&1; then
-    echo "  lint: pass"
-  else
-    echo "  lint: fail"
-    QUALITY_VERDICT="fail"
-    FINDINGS_IMPORTANT+=("Lint errors in unit branch")
-  fi
-
-  # Check: type-check
-  if pnpm type-check >/dev/null 2>&1; then
-    echo "  type_check: pass"
-  else
-    echo "  type_check: fail"
-    QUALITY_VERDICT="fail"
-    FINDINGS_IMPORTANT+=("Type errors in unit branch")
-  fi
-
-  # Check: build
-  if pnpm build >/dev/null 2>&1; then
-    echo "  build: pass"
-  else
-    echo "  build: fail"
-    QUALITY_VERDICT="fail"
-    FINDINGS_CRITICAL+=("Build failure in unit branch")
-  fi
-
-  echo "  quality_verdict: $QUALITY_VERDICT"
-fi
-
-# ─── Verdict Summary ────────────────────────────────────────────────────────
-if [[ "$SPEC_VERDICT" == "pass" && "$QUALITY_VERDICT" == "pass" ]]; then
-  OVERALL="pass"
-  DISPOSITION="eligible_for_merge"
-elif [[ "$SPEC_VERDICT" == "fail" || "$QUALITY_VERDICT" == "fail" ]]; then
-  OVERALL="fail"
-  DISPOSITION="needs_fix_or_exclude"
-else
-  OVERALL="incomplete"
-  DISPOSITION="blocked"
-fi
-
-echo "verdict:"
-echo "  overall: $OVERALL"
-echo "  spec_compliance: $SPEC_VERDICT"
-echo "  code_quality: $QUALITY_VERDICT"
-echo "  retry_count: $RETRY_COUNT"
-echo "  disposition: $DISPOSITION"
-echo "  findings:"
-echo "    critical:"
-for f in "${FINDINGS_CRITICAL[@]:-}"; do
-  [[ -n "$f" ]] && echo "      - \"$f\""
-done
-echo "    important:"
-for f in "${FINDINGS_IMPORTANT[@]:-}"; do
-  [[ -n "$f" ]] && echo "      - \"$f\""
-done
-echo "    minor:"
-for f in "${FINDINGS_MINOR[@]:-}"; do
-  [[ -n "$f" ]] && echo "      - \"$f\""
-done
-
-# ─── Fix-Loop ────────────────────────────────────────────────────────────────
-# The orchestrator agent drives the fix-loop:
-# 1. If verdict is "fail" and retries remain → action: retry
-#    Orchestrator dispatches implementer subagent with findings,
-#    then re-runs this script with --retry-count <N+1>
-# 2. If verdict is "fail" and retry_count >= retry_limit → action: dispatch_fix
-#    Terminal failure — manual intervention or exclusion needed
-# 3. If verdict is "pass" → action: finalize
-
-echo "fix_loop:"
-echo "  retry_count: $RETRY_COUNT"
-echo "  retry_limit: $RETRY_LIMIT"
-if [[ "$OVERALL" == "fail" ]]; then
-  if [[ $RETRY_COUNT -lt $RETRY_LIMIT ]]; then
-    echo "  action: retry"
-    echo "  next_retry_count: $((RETRY_COUNT + 1))"
-  else
-    echo "  action: dispatch_fix"
-  fi
-else
-  echo "  action: finalize"
-fi
-
-echo "---"