@open-agent-toolkit/cli 0.0.10

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

@@ -0,0 +1,118 @@
+# 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

@@ -0,0 +1,133 @@
+#!/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

@@ -0,0 +1,182 @@
+#!/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

@@ -0,0 +1,187 @@
+#!/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 "---"