implementation.json

{
  "name": "implementation",
  "description": "Plan, implement, test, and merge a task end-to-end",
  "summary": "bootstrap_clone > (claim_and_resolve?) > (create_and_publish?) > make-plan > (review-approach?) > dry-walkthrough > implement > test > merge (per plan part) > (audit-impl?) > (open_pr?) > push > cleanup",
  "recipe_version": "1.0.0",
  "requires_packs": [
    "github",
    "ci",
    "clone",
    "telemetry"
  ],
  "ingredients": {
    "task": {
      "description": "What to implement",
      "required": true
    },
    "source_dir": {
      "description": "Source repository",
      "required": false,
      "default": "",
      "authority": "config"
    },
    "run_name": {
      "description": "Run name prefix",
      "default": "impl"
    },
    "base_branch": {
      "description": "Merge target",
      "default": "",
      "authority": "config"
    },
    "review_approach": {
      "description": "Research approaches first",
      "default": "false"
    },
    "audit_impl": {
      "description": "Post-merge quality gate",
      "default": "true"
    },
    "open_pr": {
      "description": "PR instead of direct merge",
      "default": "true"
    },
    "arch_lenses": {
      "description": "Generate architecture lens diagrams for the PR",
      "default": "false"
    },
    "backend_supports_git_write": {
      "description": "Whether the session backend supports .git/ metadata writes (git commit, rebase, worktree add). Resolved from backend capabilities at load time.",
      "default": "true",
      "hidden": true,
      "authority": "config"
    },
    "auto_merge": {
      "description": "Automatically merge the PR after required checks pass — via merge queue when available, direct merge otherwise",
      "default": "true"
    },
    "batch_dispatch": {
      "description": "Pack multiple parallel-safe issues per food truck. When \"true\", the fleet dispatcher batches parallel-safe issues (up to max_issues_per_food_truck) into implement-findings food trucks with comma-separated issue_urls.",
      "default": "false"
    },
    "review_max_retries": {
      "description": "Maximum number of review-resolve retry cycles before proceeding to CI",
      "default": "3"
    },
    "local_review_rounds": {
      "description": "Number of review-resolve cycles to run locally before switching to GitHub-backed review. 0 disables local mode entirely.",
      "type": "integer",
      "default": "2",
      "authority": "config"
    },
    "merge_fix_max_retries": {
      "description": "Maximum number of merge-fix retry cycles before failing",
      "default": "3"
    },
    "audit_remediation_max_retries": {
      "description": "Maximum number of audit remediation cycles (audit NO GO recovery) before failing",
      "default": "2"
    },
    "test_fix_max_retries": {
      "default": "3",
      "description": "Maximum iterations of the pre-merge test → fix → test cycle.",
      "hidden": true
    },
    "merge_test_fix_max_retries": {
      "default": "3",
      "description": "Maximum iterations of the merge-gate test → fix → test cycle.",
      "hidden": true
    },
    "adversarial_review_level": {
      "description": "Controls adversarial review depth in make-plan. \"auto\" estimates complexity and gates agents accordingly. \"full\" always runs all 3 agents. \"none\" skips adversarial review entirely.",
      "default": "auto",
      "hidden": true,
      "authority": "config"
    },
    "issue_url": {
      "description": "GitHub issue to close on merge",
      "required": false
    },
    "upfront_claimed": {
      "description": "Set to 'true' when process-issues has already claimed this issue upfront. Allows claim_issue defense step to pass through without aborting.",
      "default": "false",
      "hidden": true
    },
    "run_mode": {
      "description": "Execution mode when processing multiple issues. Options: sequential (default, one issue at a time) or parallel (all issues simultaneously with wavefront step scheduling — fast steps for all pipelines before any slow step).",
      "default": "sequential",
      "hidden": true
    },
    "max_parallel": {
      "description": "Maximum number of issues to run in parallel within a single execution-map group. Groups exceeding this cap are split into sequential sub-groups. Passed to build-execution-map. Must be a positive integer (expressed as a string).",
      "default": "6",
      "hidden": true
    },
    "post_run_diagnostics": {
      "description": "Run diagnostic analysis after pipeline completion",
      "default": "false",
      "hidden": true,
      "authority": "config"
    },
    "kitchen_id": {
      "description": "Kitchen session identifier (auto-injected)",
      "default": "",
      "hidden": true
    },
    "is_fleet_dispatch": {
      "description": "Whether running as an L2 food truck dispatch (auto-injected)",
      "default": "false",
      "hidden": true,
      "authority": "config"
    },
    "dispatch_id": {
      "description": "Fleet dispatch identifier (auto-injected, empty in non-fleet sessions)",
      "default": "",
      "hidden": true,
      "authority": "config"
    },
    "diagnostics_log_dir": {
      "description": "Resolved diagnostics log directory path (auto-injected)",
      "default": "",
      "hidden": true
    }
  },
  "kitchen_rules": [
    "NEVER use native Claude Code tools (Read, Grep, Glob, Edit, Write, Bash, Agent, WebFetch, WebSearch, NotebookEdit) from the orchestrator. All work is delegated through run_skill.",
    "Route to on_failure — never investigate or fix directly from the orchestrator.",
    "Process plan parts sequentially. Complete the full cycle (verify → implement → test → merge) for one part before starting the next. Do NOT run verify for all parts upfront.",
    "By default (open_pr=true), a feature branch is created with a unique name derived from inputs.run_name and context.issue_number (e.g. impl/124) or a date suffix (e.g. impl/20260304) when no issue is available. All worktree merges target the feature branch (context.merge_target), not base_branch directly. The push step publishes the feature branch, then prepare_pr → run_arch_lenses → compose_pr opens a PR to base_branch. When open_pr=false, merges target base_branch directly and prepare_pr is skipped.",
    "When arch_lenses=true (and open_pr=true), prepare_pr routes through run_arch_lenses before compose_pr, adding architecture lens diagrams to the PR. By default arch_lenses is off and prepare_pr routes directly to compose_pr.",
    "SOURCE ISOLATION: After bootstrap_clone returns, the source_dir is strictly off-limits. Never run any command in source_dir — no git checkout, git fetch, git reset, git pull, run_cmd, run_skill, or any other operation. All work — skill invocations, git operations, file reads — happens exclusively in the clone (work_dir). source_dir is used ONLY to read the remote URL inside push_to_remote.",
    "MERGE ROUTING: check_repo_merge_state performs a single GraphQL round-trip to detect queue_available, merge_group_trigger, and auto_merge_available for the target branch. route_queue_mode then routes to: enable_auto_merge → wait_for_queue ONLY when queue_available=true AND merge_group_trigger=true; direct_merge → wait_for_direct_merge (no queue or trigger missing, autoMergeAllowed=true); or immediate_merge → wait_for_immediate_merge (no queue, autoMergeAllowed=false). Never call gh pr merge directly via run_cmd — all merges go through these named recipe steps so CI enforcement and conflict routing are preserved."
  ],
  "steps": {
    "clone": {
      "tool": "bootstrap_clone",
      "with": {
        "source_dir": "${{ inputs.source_dir }}",
        "run_name": "${{ inputs.run_name }}",
        "base_branch": "${{ inputs.base_branch }}",
        "step_name": "bootstrap_clone"
      },
      "capture": {
        "work_dir": "${{ result.work_dir }}",
        "remote_url": "${{ result.remote_url }}",
        "base_sha": "${{ result.base_sha }}",
        "merge_target": "${{ result.merge_target }}"
      },
      "on_success": "claim_and_resolve",
      "on_failure": "escalate_stop",
      "note": "Clones source_dir and captures base_sha + merge_target in one turn. Returns work_dir, remote_url, base_sha (SHA of base_branch before any merge), and merge_target (set to base_branch as fallback; overridden by create_and_publish when open_pr=true). On failure, escalate_stop immediately (no clone to remove).\n"
    },
    "claim_and_resolve": {
      "tool": "claim_and_resolve_issue",
      "optional": true,
      "skip_when_false": "inputs.issue_url",
      "with": {
        "issue_url": "${{ inputs.issue_url }}",
        "allow_reentry": "${{ inputs.upfront_claimed }}"
      },
      "capture": {
        "issue_number": "${{ result.issue_number }}",
        "issue_title": "${{ result.issue_title }}",
        "issue_slug": "${{ result.issue_slug }}",
        "claimed": "${{ result.claimed }}"
      },
      "on_result": [
        {
          "when": "${{ result.claimed }} == true",
          "route": "create_and_publish"
        },
        {
          "route": "register_clone_failure"
        }
      ],
      "on_failure": "register_clone_failure",
      "note": "Fetches issue title/slug and claims the issue in one turn. Returns issue_number, issue_title, issue_slug, and claimed boolean. When claimed=false (another session owns it), routes to register_clone_failure before escalate_stop so the clone directory is registered for cleanup. issue_slug and issue_number are passed to create_and_publish for branch naming.\n"
    },
    "create_and_publish": {
      "tool": "create_and_publish_branch",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "with": {
        "issue_slug": "${{ context.issue_slug }}",
        "run_name": "${{ inputs.run_name }}",
        "issue_number": "${{ context.issue_number }}",
        "work_dir": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "step_name": "create_and_publish_branch"
      },
      "capture": {
        "merge_target": "${{ result.merge_target }}"
      },
      "on_success": "plan",
      "on_failure": "release_issue_failure",
      "note": "Computes branch name, creates it (with collision suffix if needed), and pushes to origin in one turn. Overrides merge_target with the feature branch name. merge_worktree requires refs/remotes/origin/{branch} to exist after fetch (step 5.5). When open_pr=false, this step is skipped and merge_target remains as base_branch.\n"
    },
    "plan": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:make-plan ${{ inputs.task }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "plan",
        "issue_url": "${{ inputs.issue_url }}",
        "issue_title": "${{ context.issue_title }}",
        "adversarial_review_level": "${{ inputs.adversarial_review_level }}",
        "output_dir": "."
      },
      "capture": {
        "plan_path": "${{ result.plan_path }}",
        "all_plan_paths": "${{ result.plan_path }}",
        "verdict": "${{ result.verdict }}"
      },
      "capture_list": {
        "plan_parts": "${{ result.plan_parts }}"
      },
      "retries": 0,
      "on_result": [
        {
          "when": "${{ result.verdict }} == plan",
          "route": "review_approach"
        },
        {
          "when": "${{ result.verdict }} == false_positive",
          "route": "check_has_commits"
        }
      ],
      "on_failure": "release_issue_failure",
      "note": "Produces plan in {{AUTOSKILLIT_TEMP}}/make-plan/. Glob plan_dir for *_part_*.md or single plan file. plan_parts context key contains the full ordered list of part files (sorted alphabetically). For a single-part plan, plan_parts has one entry equal to plan_path. REMEDIATION MODE: context.remediation_path is available when the orchestrator re-enters plan from the remediate step; pass it inline in the skill_command rather than as a named with: key. When in remediation mode, also append audit_remediation_mode=true to the skill_command. ACCUMULATION: all_plan_paths accumulates across any re-entries to the plan step (e.g. remediation). For a single-pass run, all_plan_paths equals plan_path (the capture block handles this automatically). When verdict=false_positive, do NOT overwrite all_plan_paths — preserve the existing accumulated value from prior plan executions. ISSUE CONTEXT: If inputs.issue_url is a non-empty string, append it to the skill_command so the make-plan skill can detect and fetch the issue itself: \"/autoskillit:make-plan {task}\\n\\nGitHub Issue: {inputs.issue_url}\" The skill detects the URL pattern and calls fetch_github_issue internally. ADVERSARIAL REVIEW LEVEL: If inputs.adversarial_review_level is a non-empty string, append it to the skill_command: \"/autoskillit:make-plan {task}\\n\\nadversarial_review_level={inputs.adversarial_review_level}\" VERDICT: The skill emits verdict=plan (normal) or verdict=false_positive (remediation finding is a false positive). false_positive skips implement and routes to check_has_commits.\n"
    },
    "review_approach": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:review-approach ${{ context.plan_path }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "review_approach",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/review-approach"
      },
      "capture": {
        "review_path": "${{ result.review_path }}"
      },
      "retries": 1,
      "on_success": "verify",
      "on_failure": "release_issue_failure",
      "on_context_limit": "verify",
      "skip_when_false": "inputs.review_approach",
      "note": "Only execute this step if review_approach input is 'true'. Otherwise skip directly to verify."
    },
    "verify": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:dry-walkthrough ${{ context.plan_path }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "verify",
        "review_path": "${{ context.review_path }}",
        "output_dir": "{{AUTOSKILLIT_TEMP}}"
      },
      "on_success": "create_impl_worktree",
      "on_failure": "release_issue_failure",
      "note": "SEQUENTIAL EXECUTION: For each plan_part, run the FULL cycle — verify → implement → test → merge — for that part before advancing to the next part. Never run verify for all parts first. If review produced a report, context.review_path is available — pass it as an additional arg to dry-walkthrough."
    },
    "create_impl_worktree": {
      "tool": "run_cmd",
      "with": {
        "cmd": "bash {{AUTOSKILLIT_SCRIPTS}}/create_impl_worktree.sh \"impl-${{ context.issue_number }}-$(date +%Y%m%d-%H%M%S)\" \"{{AUTOSKILLIT_TEMP}}\"",
        "cwd": "${{ context.work_dir }}",
        "step_name": "create_impl_worktree"
      },
      "capture": {
        "worktree_path": "${{ result.worktree_path }}"
      },
      "on_success": "implement",
      "on_failure": "release_issue_failure",
      "note": "Creates worktree at orchestrator level (unsandboxed) so .git/ metadata writes succeed regardless of backend sandbox constraints."
    },
    "implement": {
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "with": {
        "skill_command": "/autoskillit:implement-worktree-no-merge ${{ context.plan_path }}",
        "cwd": "${{ context.worktree_path }}",
        "step_name": "implement",
        "output_dir": "."
      },
      "capture": {
        "worktree_path": "${{ result.worktree_path }}",
        "has_implementation_progress": "${{ result.has_implementation_progress }}"
      },
      "retries": 0,
      "on_context_limit": "retry_worktree",
      "on_success": "gate_backend_write",
      "on_failure": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write",
      "note": "Extracts worktree_path from result for use in subsequent steps."
    },
    "retry_worktree": {
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "with": {
        "skill_command": "/autoskillit:retry-worktree ${{ context.plan_path }} ${{ context.worktree_path }}",
        "cwd": "${{ context.worktree_path }}",
        "step_name": "retry_worktree",
        "output_dir": "."
      },
      "capture": {
        "worktree_path": "${{ result.worktree_path }}",
        "phases_implemented": "${{ result.phases_implemented }}",
        "has_implementation_progress": "${{ result.has_implementation_progress }}",
        "deviation_manifest_path": {
          "from": "${{ result.deviation_manifest_path }}",
          "type": "optional_string"
        }
      },
      "on_result": [
        {
          "when": "${{ result.phases_implemented }} > 0",
          "route": "check_changes"
        },
        {
          "route": "check_changes"
        }
      ],
      "on_context_limit": "check_changes",
      "on_exhausted": "release_issue_failure",
      "on_failure": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write"
    },
    "gate_backend_write": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.gate_backend_write",
        "backend_supports_git_write": "${{ inputs.backend_supports_git_write }}"
      },
      "on_result": [
        {
          "when": "${{ result.backend_capable }} == false",
          "route": "release_issue_failure"
        },
        {
          "route": "check_changes"
        }
      ],
      "on_failure": "release_issue_failure"
    },
    "check_changes": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.detect_zero_changes",
        "worktree_path": "${{ context.worktree_path }}",
        "base_branch": "${{ inputs.base_branch }}",
        "write_evidence_override": "${{ context.has_implementation_progress }}"
      },
      "capture": {
        "has_changes": "${{ result.has_changes }}",
        "commit_count": "${{ result.commit_count }}"
      },
      "on_result": [
        {
          "when": "${{ result.has_changes }} == false",
          "route": "close_issue_no_changes"
        },
        {
          "route": "test"
        }
      ],
      "on_failure": "release_issue_failure"
    },
    "close_issue_no_changes": {
      "description": "Release issue after zero-change detection — stages on non-default branch, closes on promotion target",
      "tool": "release_issue",
      "optional": true,
      "skip_when_false": "inputs.issue_url",
      "with": {
        "issue_url": "${{ inputs.issue_url }}",
        "target_branch": "${{ inputs.base_branch }}",
        "close_issue": "true"
      },
      "on_success": "register_clone_no_changes",
      "on_failure": "register_clone_no_changes",
      "note": "Zero changes detected post-implement. Passes target_branch so release_issue stages on non-default branches (base_branch != promotion_target) or closes on the promotion target branch. close_issue is silently ignored by release_issue when staging applies (Branch 1 takes precedence over Branch 3). Routes to register_clone_no_changes for clone cleanup and distinct terminal."
    },
    "test": {
      "tool": "test_check",
      "with": {
        "worktree_path": "${{ context.worktree_path }}"
      },
      "on_success": "commit_guard",
      "on_failure": "check_test_fix_loop"
    },
    "check_merge_fix_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.merge_fix_count }}",
        "max_iterations": "${{ inputs.merge_fix_max_retries }}"
      },
      "capture": {
        "merge_fix_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "diagnose_merge_gate"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "merge_fix_count"
      ],
      "note": "Merge-failure iteration guard (dirty_tree / test_gate / post_rebase_test_gate). Shares merge_fix_count with check_merge_rebase_loop and check_dirty_main_retry.\n"
    },
    "diagnose_merge_gate": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.diagnose_merge_gate",
        "test_stdout": "${{ context.merge_test_stdout }}",
        "test_stderr": "${{ context.merge_test_stderr }}",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/diagnose-merge-gate",
        "work_dir": "${{ context.work_dir }}",
        "failed_step": "${{ context.merge_failed_step }}"
      },
      "capture": {
        "merge_gate_diagnosis_path": "${{ result.diagnosis_path }}",
        "merge_gate_ci_conclusion": "${{ result.ci_conclusion }}"
      },
      "on_success": "merge_gate_fix",
      "on_failure": "merge_gate_fix",
      "optional_context_refs": [
        "merge_test_stdout",
        "merge_test_stderr",
        "merge_failed_step"
      ],
      "note": "Writes a structured diagnosis file from merge gate test output, mirroring diagnose-ci format. Routes to fix on both success and failure — fix proceeds without context if diagnosis fails. Uses distinct context keys (merge_gate_*) to avoid collision with ci_watch/diagnose_ci context variables from the CI path.\n"
    },
    "check_merge_rebase_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.merge_fix_count }}",
        "max_iterations": "${{ inputs.merge_fix_max_retries }}"
      },
      "capture": {
        "merge_fix_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "rebase_conflict_fix"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "merge_fix_count"
      ],
      "note": "Merge-failure iteration guard for rebase conflicts. Shares merge_fix_count with check_merge_fix_loop and check_dirty_main_retry.\n"
    },
    "check_dirty_main_retry": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.merge_fix_count }}",
        "max_iterations": "${{ inputs.merge_fix_max_retries }}"
      },
      "capture": {
        "merge_fix_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "commit_guard"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "merge_fix_count"
      ],
      "note": "Merge-failure iteration guard for dirty_main_repo retries. Shares merge_fix_count with check_merge_fix_loop and check_merge_rebase_loop.\n"
    },
    "check_ref_push_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.ref_push_count }}",
        "max_iterations": "2"
      },
      "capture": {
        "ref_push_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "ref_push"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "ref_push_count"
      ],
      "note": "Ref-coherence recovery guard. Uses a SEPARATE counter (ref_push_count, max 2) from merge_fix_count. Push-and-retry is cheap and near-deterministic (no LLM invocation), so it does not share the merge_fix_count budget. If max exceeded, the divergence is not fixable by pushing — escalate.\n"
    },
    "ref_push": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "commit_guard",
      "on_failure": "release_issue_failure",
      "note": "Pushes the feature branch to remote to resolve ref_coherence divergence. After push, routes back to commit_guard → main_repo_guard → merge to retry the merge with aligned local/remote SHAs.\n"
    },
    "check_audit_remediation_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.audit_remediation_count }}",
        "max_iterations": "${{ inputs.audit_remediation_max_retries }}"
      },
      "capture": {
        "audit_remediation_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "remediate"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "audit_remediation_count"
      ],
      "note": "Guards the audit_impl → remediate → plan → implement → test remediation cycle. Separate counter from merge_fix_count.\n"
    },
    "commit_guard": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.commit_guard",
        "worktree_path": "${{ context.worktree_path }}",
        "base_branch": "${{ inputs.base_branch }}"
      },
      "on_result": [
        {
          "when": "${{ result.committed }} == 'regression_detected'",
          "route": "release_issue_failure"
        },
        {
          "route": "main_repo_guard"
        }
      ],
      "on_failure": "main_repo_guard",
      "note": "Belt-and-suspenders guard: auto-commits any uncommitted changes before merge. Catches dirty state from context-exhausted skills, cascading pre-commit auto-fixes, or any other source. Routes to main_repo_guard to handle dirty main repo state.\n"
    },
    "main_repo_guard": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.main_repo_guard",
        "clone_path": "${{ context.work_dir }}"
      },
      "on_result": [
        {
          "when": "${{ result.cleaned }} == 'failed'",
          "route": "release_issue_failure"
        },
        {
          "route": "merge"
        }
      ],
      "on_failure": "merge",
      "note": "Stashes uncommitted changes in the main repo before merge. Catches dirty state from infrastructure-terminated sessions that left artifacts in the clone. Routes to merge on both success and failure (merge's dirty_main_repo gate handles persistent issues).\n"
    },
    "merge": {
      "tool": "merge_worktree",
      "with": {
        "worktree_path": "${{ context.worktree_path }}",
        "base_branch": "${{ context.merge_target }}"
      },
      "capture": {
        "cleanup_succeeded": "${{ result.cleanup_succeeded }}",
        "worktree_path": "${{ result.worktree_path }}",
        "merge_test_stdout": "${{ result.test_stdout }}",
        "merge_test_stderr": "${{ result.test_stderr }}",
        "merge_failed_step": "${{ result.failed_step }}"
      },
      "on_result": [
        {
          "when": "result.failed_step == 'dirty_tree'",
          "route": "check_merge_fix_loop"
        },
        {
          "when": "result.failed_step == 'test_gate'",
          "route": "check_merge_fix_loop"
        },
        {
          "when": "result.failed_step == 'post_rebase_test_gate'",
          "route": "check_merge_fix_loop"
        },
        {
          "when": "result.failed_step == 'rebase'",
          "route": "check_merge_rebase_loop"
        },
        {
          "when": "result.failed_step == 'dirty_main_repo'",
          "route": "check_dirty_main_retry"
        },
        {
          "when": "result.failed_step == 'ref_coherence'",
          "route": "check_ref_push_loop"
        },
        {
          "when": "result.error",
          "route": "release_issue_failure"
        },
        {
          "route": "inter_part_push"
        }
      ],
      "on_failure": "release_issue_failure",
      "note": "After merge, route to inter_part_push to sync the remote branch, then next_or_done to process remaining parts before pushing. By default (open_pr=true), merge_target is the feature branch named from run_name. When open_pr=false, merge_target equals base_branch — merges go directly to base. dirty_tree and test_gate failures route to fix (resolve-failures) for recovery; all other failures route to release_issue_failure.\n"
    },
    "check_has_commits": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_commits_ahead",
        "cwd": "${{ context.work_dir }}",
        "base_branch": "${{ inputs.base_branch }}"
      },
      "on_result": [
        {
          "when": "${{ result.has_commits }}",
          "route": "push"
        },
        {
          "route": "close_issue_already_done"
        }
      ],
      "on_failure": "release_issue_failure"
    },
    "close_issue_already_done": {
      "description": "Close issue as already-implemented when branch has zero commits ahead of base",
      "tool": "run_python",
      "optional": true,
      "skip_when_false": "inputs.issue_url",
      "with": {
        "callable": "autoskillit.smoke_utils.close_issue_already_done",
        "issue_url": "${{ inputs.issue_url }}"
      },
      "on_success": "register_clone_already_done",
      "on_failure": "register_clone_already_done",
      "note": "Zero commits ahead of base means the feature is already merged. Remove in-progress label, close issue with \"already implemented\" comment, and route to clone cleanup with distinct terminal.\n"
    },
    "push": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "prepare_pr",
      "on_failure": "release_issue_failure",
      "note": "Runs once at the end, after check_has_commits confirms commits exist. Pushes merge_target branch from the clone to the upstream remote. By default (open_pr=true), this pushes the feature branch; when open_pr=false, pushes base_branch. Uses the pre-resolved remote_url captured at clone time, preserving clone isolation. On success, routes to prepare_pr (which opens the PR by default; skipped when open_pr=false). On failure, release_issue_failure registers the clone and escalates.\n"
    },
    "fix": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-failures ${{ context.worktree_path }} ${{ context.plan_path }} ${{ inputs.base_branch }} ${{ context.merge_gate_ci_conclusion }} - ${{ context.merge_gate_diagnosis_path }}",
        "cwd": "${{ context.worktree_path }}",
        "step_name": "fix",
        "output_dir": "."
      },
      "capture": {
        "verdict": "${{ result.verdict }}",
        "fixes_applied": "${{ result.fixes_applied }}",
        "deviation_manifest_path": {
          "from": "${{ result.deviation_manifest_path }}",
          "type": "optional_string"
        }
      },
      "on_result": [
        {
          "when": "${{ result.verdict }} == 'real_fix'",
          "route": "test"
        },
        {
          "when": "${{ result.verdict }} == 'already_green'",
          "route": "test"
        },
        {
          "when": "${{ result.verdict }} == 'flake_suspected'",
          "route": "test"
        },
        {
          "when": "${{ result.verdict }} == 'ci_only_failure'",
          "route": "release_issue_failure"
        },
        {
          "when": "${{ result.verdict }} == 'no_test_infrastructure'",
          "route": "release_issue_failure"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "on_failure": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "on_rate_limit": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write",
      "optional_context_refs": [
        "merge_gate_ci_conclusion",
        "merge_gate_diagnosis_path"
      ],
      "note": "Fixes test failures without merging. Routes to test for verification; test failure increments check_test_fix_loop before retrying."
    },
    "check_test_fix_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.test_fix_loop_count }}",
        "max_iterations": "${{ inputs.test_fix_max_retries }}"
      },
      "capture": {
        "test_fix_loop_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "fix"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "test_fix_loop_count"
      ],
      "note": "Guards the pre-merge test → fix → test cycle. Caps at test_fix_max_retries iterations (default 3). Counter increments after test failure, so the last fix attempt always gets verified before the budget is exhausted."
    },
    "merge_gate_fix": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-failures ${{ context.worktree_path }} ${{ context.plan_path }} ${{ inputs.base_branch }} ${{ context.merge_gate_ci_conclusion }} - ${{ context.merge_gate_diagnosis_path }}",
        "cwd": "${{ context.worktree_path }}",
        "step_name": "merge_gate_fix",
        "output_dir": "."
      },
      "capture": {
        "verdict": "${{ result.verdict }}",
        "fixes_applied": "${{ result.fixes_applied }}",
        "deviation_manifest_path": {
          "from": "${{ result.deviation_manifest_path }}",
          "type": "optional_string"
        }
      },
      "on_result": [
        {
          "when": "${{ result.verdict }} == 'real_fix'",
          "route": "merge_gate_test"
        },
        {
          "when": "${{ result.verdict }} == 'already_green'",
          "route": "merge_gate_test"
        },
        {
          "when": "${{ result.verdict }} == 'flake_suspected'",
          "route": "merge_gate_test"
        },
        {
          "when": "${{ result.verdict }} == 'ci_only_failure'",
          "route": "release_issue_failure"
        },
        {
          "when": "${{ result.verdict }} == 'no_test_infrastructure'",
          "route": "release_issue_failure"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "on_failure": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "on_rate_limit": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write",
      "optional_context_refs": [
        "merge_gate_ci_conclusion",
        "merge_gate_diagnosis_path"
      ],
      "note": "Merge-gate-path variant of fix. Uses a separate counter (merge_test_fix_loop_count) so merge-gate retries do not drain the pre-merge test fix budget."
    },
    "merge_gate_test": {
      "tool": "test_check",
      "with": {
        "worktree_path": "${{ context.worktree_path }}"
      },
      "on_success": "commit_guard",
      "on_failure": "check_merge_test_fix_loop"
    },
    "check_merge_test_fix_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.merge_test_fix_loop_count }}",
        "max_iterations": "${{ inputs.merge_test_fix_max_retries }}"
      },
      "capture": {
        "merge_test_fix_loop_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "merge_gate_fix"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "merge_test_fix_loop_count"
      ],
      "note": "Merge-gate test fix iteration guard. Uses merge_test_fix_loop_count (independent of test_fix_loop_count) to prevent merge-gate retries from consuming the pre-merge fix budget."
    },
    "rebase_conflict_fix": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.worktree_path }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.worktree_path }}",
        "step_name": "rebase_conflict_fix",
        "output_dir": "."
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "test"
        }
      ],
      "on_failure": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "retries": 1,
      "on_exhausted": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write"
    },
    "inter_part_push": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "next_or_done",
      "on_failure": "next_or_done",
      "note": "Pushes the feature branch to remote after each part's merge succeeds. Closes the ref_coherence divergence window between multi-part merges. Routes to next_or_done on both success and failure — push failure here is not fatal; the ref_coherence recovery route handles it if the next part's merge detects divergence.\n"
    },
    "next_or_done": {
      "action": "route",
      "on_result": [
        {
          "when": "${{ result.next }} == more_parts",
          "route": "verify"
        },
        {
          "route": "audit_impl"
        }
      ],
      "note": "Routing step — no tool call. The agent evaluates what comes next: 1. If more plan_parts remain for the current plan → go to verify with next part. 2. If all plan_parts are complete → go to audit_impl.\n"
    },
    "audit_impl": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:audit-impl ${{ context.all_plan_paths }} ${{ context.base_sha }} ${{ inputs.base_branch }} deviation_manifest_path=${{ context.deviation_manifest_path }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "audit_impl",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/audit-impl"
      },
      "capture": {
        "remediation_path": "${{ result.remediation_path }}"
      },
      "on_result": [
        {
          "when": "${{ result.verdict }} == GO",
          "route": "check_has_commits"
        },
        {
          "when": "result.error",
          "route": "register_clone_failure"
        },
        {
          "route": "check_audit_remediation_loop"
        }
      ],
      "on_failure": "register_clone_failure",
      "on_context_limit": "register_clone_failure",
      "optional": true,
      "skip_when_false": "inputs.audit_impl",
      "optional_context_refs": [
        "deviation_manifest_path"
      ],
      "note": "Only execute if inputs.audit_impl is 'true'. If false, skip directly to check_has_commits. Captures verdict and remediation_path. Routes GO → push, NO GO → remediate which re-enters the plan step with the remediation file. All parts have been merged at this point — no worktree exists. Uses context.base_sha (a stable commit SHA captured before any merge began) as implementation_ref. A SHA names a git object and survives git branch -D unconditionally. HEAD points to merge_target (the feature branch tip when open_pr=true, or base_branch when open_pr=false). The diff git diff base_sha..HEAD covers the full implementation.\n"
    },
    "remediate": {
      "action": "route",
      "with": {
        "remediation_path": "${{ context.remediation_path }}"
      },
      "on_success": "plan"
    },
    "prepare_pr": {
      "tool": "run_skill",
      "model": "",
      "retries": 1,
      "with": {
        "skill_command": "/autoskillit:prepare-pr ${{ context.all_plan_paths }} ${{ inputs.run_name }} ${{ inputs.base_branch }} ${{ context.issue_number }} ${{ inputs.arch_lenses }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "prepare_pr"
      },
      "capture": {
        "prep_path": "${{ result.prep_path }}",
        "selected_lenses": "${{ result.selected_lenses }}",
        "lens_context_paths": "${{ result.lens_context_paths }}"
      },
      "on_result": [
        {
          "when": "${{ result.prep_path }} and ${{ inputs.arch_lenses }} == 'true'",
          "route": "run_arch_lenses"
        },
        {
          "when": "${{ result.prep_path }}",
          "route": "compose_pr"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "on_failure": "release_issue_failure",
      "on_context_limit": "prepare_pr",
      "on_exhausted": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "Reads plan(s), runs git diff, classifies changed files, selects 1–3 arch-lens slugs, writes one PR context file per lens, and writes a PR prep file. Does NOT invoke arch-lens skills.\n"
    },
    "run_arch_lenses": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:arch-lens-{slug} {context_path}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "run_arch_lenses"
      },
      "capture_list": {
        "all_diagram_paths": "${{ result.diagram_path }}"
      },
      "retries": 0,
      "on_success": "compose_pr",
      "on_failure": "compose_pr",
      "on_context_limit": "compose_pr",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "LENS ITERATION: context.selected_lenses contains comma-separated arch-lens slugs (e.g. \"module-dependency,process-flow\"). context.lens_context_paths contains the corresponding comma-separated context file paths (same order as slugs). For each lens slug, run:\n  /autoskillit:arch-lens-{slug} {matching_context_path}\nRun all selected lenses in parallel (all run_skill calls in a single message). Accumulate each diagram_path value into context.all_diagram_paths via capture_list. If a lens fails, continue with remaining lenses — compose_pr handles empty lists gracefully by omitting the Architecture Impact section.\n"
    },
    "compose_pr": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:compose-pr ${{ context.prep_path }} \"${{ context.all_diagram_paths }}\" ${{ context.work_dir }} ${{ inputs.base_branch }} ${{ context.issue_number }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "compose_pr"
      },
      "capture": {
        "pr_url": {
          "from": "${{ result.pr_url }}",
          "type": "optional_string"
        }
      },
      "on_result": [
        {
          "when": "${{ result.pr_url }}",
          "route": "guard_pr_url"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "on_failure": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "Reads the PR prep file, validates arch-lens diagrams (must contain ★ or ●), composes the PR body, and runs gh pr create. Degrades gracefully if gh is unavailable (emits pr_url=).\nsynthesis_algorithm: null — arch-lens readings forwarded to compose_pr without aggregation. Dial (prepare_pr) -> Apply (run_arch_lenses) -> Output (compose_pr).\n"
    },
    "guard_pr_url": {
      "action": "route",
      "on_result": [
        {
          "when": "${{ context.pr_url }}",
          "route": "extract_pr_number"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "note": "Guard — skip PR extraction if pr_url is empty (graceful degradation from compose_pr)."
    },
    "extract_pr_number": {
      "tool": "run_cmd",
      "with": {
        "cmd": "gh pr view '${{ context.merge_target }}' --json number -q .number",
        "cwd": "${{ context.work_dir }}",
        "step_name": "extract_pr_number"
      },
      "capture": {
        "pr_number": "${{ result.stdout | trim }}"
      },
      "on_success": "init_review_loop_count",
      "on_failure": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "Extracts the PR number as a string for downstream steps. pr_number is required by the queue finale steps (enable_auto_merge, wait_for_queue).\n"
    },
    "init_review_loop_count": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.init_counter",
        "counter_value": "${{ context.review_loop_count }}"
      },
      "capture": {
        "review_loop_count": "${{ result.value }}"
      },
      "on_success": "annotate_pr_diff",
      "on_failure": "annotate_pr_diff",
      "optional_context_refs": [
        "review_loop_count"
      ]
    },
    "annotate_pr_diff": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.annotate_pr_diff",
        "pr_number": "${{ context.pr_number }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/review-pr/iter_${{ context.review_loop_count }}",
        "base_branch": "${{ inputs.base_branch }}",
        "local_review_rounds": "${{ inputs.local_review_rounds }}",
        "current_iteration": "${{ context.review_loop_count }}",
        "work_dir": "${{ context.work_dir }}"
      },
      "capture": {
        "annotated_diff_path": "${{ result.annotated_diff_path }}",
        "hunk_ranges_path": "${{ result.hunk_ranges_path }}",
        "valid_lines_path": "${{ result.valid_lines_path }}",
        "diff_metrics_path": "${{ result.diff_metrics_path }}",
        "review_mode": "${{ result.review_mode }}",
        "pr_head_sha": "${{ result.head_sha }}"
      },
      "on_success": "review_pr",
      "on_failure": "review_pr",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "optional_context_refs": [
        "review_loop_count"
      ],
      "note": "Pre-computes annotated diff with [LNNN] markers and hunk ranges JSON for review-pr. On failure, falls through to review_pr which uses empty fallback.\n"
    },
    "review_pr": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:review-pr ${{ context.merge_target }} ${{ inputs.base_branch }} annotated_diff_path=${{ context.annotated_diff_path }} hunk_ranges_path=${{ context.hunk_ranges_path }} valid_lines_path=${{ context.valid_lines_path }} diff_metrics_path=${{ context.diff_metrics_path }} mode=${{ context.review_mode }} pr_head_sha=${{ context.pr_head_sha }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "review_pr",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/review-pr/iter_${{ context.review_loop_count }}"
      },
      "capture": {
        "review_verdict": "${{ result.verdict }}"
      },
      "on_result": [
        {
          "when": "${{ result.verdict }} == changes_requested",
          "route": "enrich_diff_context"
        },
        {
          "when": "${{ result.verdict }} == approved_with_comments",
          "route": "enrich_diff_context"
        },
        {
          "when": "${{ result.verdict }} == needs_human",
          "route": "check_review_loop"
        },
        {
          "when": "${{ result.verdict }} == approved",
          "route": "check_review_loop"
        },
        {
          "route": "check_review_loop"
        }
      ],
      "on_failure": "check_repo_ci_event",
      "on_context_limit": "check_repo_ci_event",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "optional_context_refs": [
        "review_loop_count",
        "review_mode"
      ],
      "note": "Runs after compose_pr creates the PR. Invokes the review-pr skill as a headless session to leave inline review comments on the PR. The skill finds the open PR by feature branch name (context.merge_target). Captures verdict as review_verdict and routes via on_result: changes_requested/approved_with_comments → enrich_diff_context → resolve_review; all other verdicts (including approved, needs_human) → check_review_loop (mandatory waypoint to increment review_loop_count). On tool-level failure (MCP error, gh unavailable), routes to check_repo_ci_event (no review to resolve). Skipped when open_pr=false.\n"
    },
    "enrich_diff_context": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.enrich_diff_context",
        "pr_number": "${{ context.pr_number }}",
        "project_dir": "${{ context.work_dir }}",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/review-pr/iter_${{ context.review_loop_count }}"
      },
      "on_success": "resolve_review",
      "on_failure": "resolve_review",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "optional_context_refs": [
        "review_loop_count"
      ],
      "note": "Enriches the review-pr diff_context handoff file with deterministic code_region extraction from the annotated diff. On failure, falls through to resolve_review which uses fallback file-read behavior.\n"
    },
    "resolve_review": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-review ${{ context.merge_target }} ${{ inputs.base_branch }} mode=${{ context.review_mode }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_review"
      },
      "capture": {
        "verdict": "${{ result.verdict }}"
      },
      "retries": 2,
      "on_exhausted": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "on_result": [
        {
          "when": "${{ result.verdict }} == 'real_fix'",
          "route": "pre_review_rebase"
        },
        {
          "when": "${{ result.verdict }} == 'already_green'",
          "route": "pre_review_rebase"
        },
        {
          "when": "${{ result.verdict }} == 'flake_suspected'",
          "route": "pre_review_rebase"
        },
        {
          "when": "${{ result.verdict }} == 'ci_only_failure'",
          "route": "release_issue_failure"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write",
      "optional_context_refs": [
        "review_mode"
      ],
      "note": "Runs when review_pr reports issues (verdict=changes_requested). The clone (context.work_dir) has the feature branch (context.merge_target) checked out. resolve-review fetches inline and summary review comments via the GitHub API, applies fixes for each actionable finding (critical + warning severity), and commits each fix. Routes via on_result: verdict dispatch — real_fix/already_green/ flake_suspected all route to pre_review_rebase (fetch+rebase before push); ci_only_failure escalates to release_issue_failure.\n"
    },
    "pre_review_rebase": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.review_path_rebase",
        "args": {
          "work_dir": "${{ context.work_dir }}",
          "base_branch": "${{ inputs.base_branch }}"
        }
      },
      "on_result": [
        {
          "when": "${{ result.status }} == clean",
          "route": "re_push_review"
        },
        {
          "route": "resolve_pre_review_conflicts"
        }
      ],
      "on_failure": "resolve_pre_review_conflicts"
    },
    "resolve_pre_review_conflicts": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_pre_review_conflicts"
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "re_push_review"
        }
      ],
      "on_failure": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "retries": 1,
      "on_exhausted": "release_issue_failure",
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write"
    },
    "re_push_review": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "check_review_loop",
      "on_failure": "release_issue_failure",
      "note": "Pushes the review-fixed feature branch back to the remote after resolve_review succeeds. Routes to check_review_loop to determine if another review-resolve cycle is needed (bounded by review_max_retries). On push failure, escalates via release_issue_failure.\n"
    },
    "check_review_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_review_loop",
        "pr_number": "${{ context.pr_number }}",
        "current_iteration": "${{ context.review_loop_count }}",
        "max_iterations": "${{ inputs.review_max_retries }}",
        "previous_verdict": "${{ context.review_verdict }}",
        "local_review_rounds": "${{ inputs.local_review_rounds }}"
      },
      "capture": {
        "review_loop_count": "${{ result.next_iteration }}",
        "review_prev_iteration": "${{ result.prev_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.had_blocking }} == true and ${{ result.max_exceeded }} == false",
          "route": "pre_review_cleanup"
        },
        {
          "route": "check_repo_ci_event"
        }
      ],
      "on_failure": "check_repo_ci_event",
      "optional_context_refs": [
        "review_loop_count",
        "review_prev_iteration",
        "review_verdict"
      ],
      "note": "Compound iteration + blocking guard. Routes back to pre_review_cleanup (then annotate_pr_diff) only when had_blocking=true AND max_exceeded=false. had_blocking is true when previous_verdict=changes_requested OR (local_review_rounds > 0 AND iteration < local_review_rounds AND verdict not in LOCAL_ROUND_EXEMPT_VERDICTS). approved_with_comments and needs_human yield had_blocking=false unconditionally — approved_with_comments because its resolve pass is one-shot, needs_human because it indicates review was skipped (graceful degradation) and re-review would be pointless.\n"
    },
    "pre_review_cleanup": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.pre_iteration_cleanup",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/review-pr/iter_${{ context.review_prev_iteration }}"
      },
      "on_success": "annotate_pr_diff",
      "on_failure": "annotate_pr_diff",
      "optional_context_refs": [
        "review_prev_iteration"
      ]
    },
    "check_repo_ci_event": {
      "tool": "check_repo_merge_state",
      "with": {
        "branch": "${{ context.merge_target }}",
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "step_name": "check_repo_ci_event",
        "base_branch": "${{ inputs.base_branch }}"
      },
      "capture": {
        "ci_event": "${{ result.ci_event }}",
        "ci_applicable": "${{ result.ci_applicable }}"
      },
      "on_success": "route_ci_applicable",
      "on_failure": "ci_watch",
      "skip_when_false": "inputs.open_pr",
      "note": "Derives ci_event for the feature branch BEFORE ci_watch runs. Uses context.merge_target (feature branch) so push.branches filter is evaluated against the actual branch being pushed, not the base branch. Non-blocking: on_failure routes to ci_watch with ci_event=null (match-any).\n"
    },
    "route_ci_applicable": {
      "action": "route",
      "on_result": [
        {
          "when": "${{ context.ci_applicable }} == false",
          "route": "check_repo_merge_state"
        },
        {
          "route": "check_pr_state"
        }
      ],
      "skip_when_false": "inputs.open_pr",
      "note": "Short-circuits CI wait when no workflow trigger matches the feature branch. ci_applicable=false means neither push nor pull_request triggers apply to this branch/base combination, so wait_for_ci would exhaust its timeout budget with zero CI runs.\n"
    },
    "check_pr_state": {
      "tool": "check_pr_mergeable",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "cwd": "${{ context.work_dir }}"
      },
      "on_result": [
        {
          "when": "${{ result.mergeable_status }} == 'CONFLICTING'",
          "route": "ci_conflict_fix"
        },
        {
          "route": "ci_watch"
        }
      ],
      "on_failure": "ci_watch",
      "skip_when_false": "inputs.open_pr",
      "note": "Pre-CI-watch gate: checks PR mergeable state before entering the CI polling loop. CONFLICTING PRs cannot trigger pull_request workflows (GitHub cannot create refs/pull/N/merge), so routing to ci_watch would produce a guaranteed no_runs. Routes CONFLICTING directly to ci_conflict_fix (resolve-merge-conflicts) — GitHub's CONFLICTING status is authoritative, no stale-base exit-code discrimination needed (mirrors merge-prs.yaml check_mergeability pattern). Routes MERGEABLE/UNKNOWN to ci_watch.\n"
    },
    "ci_watch": {
      "tool": "wait_for_ci",
      "with": {
        "branch": "${{ context.merge_target }}",
        "event": "${{ context.ci_event }}",
        "timeout_seconds": 600,
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "auto_trigger": true
      },
      "capture": {
        "ci_conclusion": "${{ result.conclusion }}",
        "ci_failed_jobs": "${{ result.failed_jobs }}"
      },
      "on_result": [
        {
          "when": "${{ result.conclusion }} == 'success'",
          "route": "check_repo_merge_state"
        },
        {
          "when": "${{ result.conclusion }} == 'no_runs'",
          "route": "handle_no_ci_runs"
        },
        {
          "when": "${{ result.conclusion }} == 'timed_out'",
          "route": "check_ci_timed_out_loop"
        },
        {
          "route": "detect_ci_conflict"
        }
      ],
      "on_failure": "detect_ci_conflict",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "Waits for the GitHub Actions CI run on context.merge_target to complete using the wait_for_ci MCP tool (timeout: 300 s). Captures structured output (conclusion + failed job names) for downstream resolve_ci. Skipped when open_pr=false — no remote feature branch is opened in that mode. Routes on result.conclusion: success → check_repo_merge_state, no_runs → handle_no_ci_runs (auto_trigger fires first: empty commit + force-push + re-poll; handle_no_ci_runs reached only when push fails), timed_out → check_ci_timed_out_loop (iteration guard), failure → detect_ci_conflict.\n"
    },
    "check_ci_timed_out_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.ci_timed_out_loop_count }}",
        "max_iterations": "2"
      },
      "capture": {
        "ci_timed_out_loop_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "detect_ci_conflict"
        },
        {
          "route": "ci_watch"
        }
      ],
      "on_failure": "detect_ci_conflict",
      "optional_context_refs": [
        "ci_timed_out_loop_count"
      ],
      "note": "Caps the ci_watch re-poll loop at 2 iterations. After 2 timed_out results (1200s total), routes to detect_ci_conflict instead of spinning indefinitely.\n"
    },
    "handle_no_ci_runs": {
      "tool": "check_repo_merge_state",
      "with": {
        "branch": "${{ context.merge_target }}",
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "step_name": "handle_no_ci_runs",
        "base_branch": "${{ inputs.base_branch }}"
      },
      "capture": {
        "ci_event": "${{ result.ci_event }}",
        "ci_applicable": "${{ result.ci_applicable }}"
      },
      "on_success": "check_ci_loop",
      "on_failure": "release_issue_failure",
      "retries": 1,
      "on_exhausted": "release_issue_failure",
      "note": "Intercepts no_runs conclusion from wait_for_ci. Re-derives ci_event using check_repo_merge_state (the original event may have been wrong for this branch's workflow configuration) and routes to check_ci_loop for iteration guard before retrying ci_watch. retries: 1 bounds the tool-call retry; check_ci_loop bounds the outer loop at 2 iterations.\n"
    },
    "check_ci_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.ci_loop_count }}",
        "max_iterations": "2"
      },
      "capture": {
        "ci_loop_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "check_active_trigger_loop"
        },
        {
          "route": "ci_watch"
        }
      ],
      "on_failure": "check_ci_already_passed",
      "optional_context_refs": [
        "ci_loop_count"
      ],
      "note": "Iteration guard for the ci_watch / handle_no_ci_runs cycle. Caps the loop at 2 iterations (initial + 1 retry after re-deriving ci_event). On budget exhaustion, routes to check_active_trigger_loop which caps the active trigger to a single attempt before escalating.\n"
    },
    "check_active_trigger_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.active_trigger_count }}",
        "max_iterations": "2"
      },
      "capture": {
        "active_trigger_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "check_ci_already_passed"
        },
        {
          "route": "trigger_ci_actively"
        }
      ],
      "on_failure": "check_ci_already_passed",
      "optional_context_refs": [
        "active_trigger_count"
      ],
      "note": "Bounds the trigger_ci_actively remediation to a single attempt. If ci_watch still returns no_runs after the active trigger, escalates to escalate_stop_no_ci rather than re-triggering indefinitely.\n"
    },
    "trigger_ci_actively": {
      "tool": "run_cmd",
      "with": {
        "cmd": "gh pr close ${{ context.pr_number }} && sleep 2 && gh pr reopen ${{ context.pr_number }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "trigger_ci_actively"
      },
      "on_success": "ci_watch",
      "on_failure": "check_ci_already_passed",
      "retries": 1,
      "on_exhausted": "check_ci_already_passed",
      "note": "Active CI trigger remediation: closes and reopens the PR to force GitHub webhook re-delivery. This re-creates the pull_request event and the refs/pull/N/merge ref (if the PR is mergeable). Routes back to ci_watch for one final attempt. If the close/reopen fails or the subsequent ci_watch still returns no_runs, escalates to escalate_stop_no_ci.\n"
    },
    "check_ci_already_passed": {
      "tool": "wait_for_ci",
      "with": {
        "branch": "${{ context.merge_target }}",
        "event": "${{ context.ci_event }}",
        "timeout_seconds": 30,
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "auto_trigger": true
      },
      "skip_when_false": "inputs.open_pr",
      "on_result": [
        {
          "when": "${{ result.conclusion }} == success",
          "route": "check_repo_merge_state"
        },
        {
          "when": "${{ result.conclusion }} == failure",
          "route": "detect_ci_conflict"
        },
        {
          "when": "${{ result.conclusion }} == timed_out",
          "route": "ci_watch"
        },
        {
          "route": "mark_issue_failed_no_ci"
        }
      ],
      "on_failure": "mark_issue_failed_no_ci",
      "note": "Safety net before terminal escalation: re-polls CI with a short timeout to detect if CI has already passed or failed despite the watcher failing to observe it. Uses wait_for_ci as the authoritative signal (30s timeout for immediate state detection). success → merge gate, failure → conflict remediation, timed_out (still pending) → ci_watch for re-poll, no_runs → terminal escalation path.\n"
    },
    "mark_issue_failed_no_ci": {
      "description": "Swap in-progress → fail label before CI failure escalation",
      "tool": "release_issue",
      "optional": true,
      "skip_when_false": "inputs.issue_url",
      "with": {
        "issue_url": "${{ inputs.issue_url }}",
        "fail_label": "fail"
      },
      "on_success": "register_clone_no_ci",
      "on_failure": "register_clone_no_ci"
    },
    "register_clone_no_ci": {
      "description": "Register clone as preserved (no-CI error pipeline)",
      "tool": "register_clone_status",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "status": "error",
        "step_name": "register_clone_no_ci"
      },
      "on_success": "run_diagnostic_no_ci",
      "on_failure": "run_diagnostic_no_ci"
    },
    "run_diagnostic_no_ci": {
      "description": "Run post-pipeline diagnostic analysis on session logs (no-CI path)",
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "optional": true,
      "skip_when_false": "inputs.post_run_diagnostics",
      "with": {
        "skill_command": "/autoskillit:analyze-pipeline-health ${{ inputs.kitchen_id }} --dispatch-id=${{ inputs.dispatch_id }} --diagnostics-log-dir=${{ inputs.diagnostics_log_dir }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "post_run_diagnostics"
      },
      "on_success": "escalate_stop_no_ci",
      "on_failure": "escalate_stop_no_ci",
      "on_context_limit": "escalate_stop_no_ci",
      "note": "Execute this diagnostic step. Failures are logged but do not alter pipeline routing.\n"
    },
    "escalate_stop_no_ci": {
      "action": "stop",
      "message": "CI safety net: statusCheckRollup returned no checks for PR ${{ context.pr_number }}. This typically means no workflow is configured to trigger on this branch pattern. Check .github/workflows/ trigger configuration. This is NOT a test failure — CI never started. Emit the L3 result sentinel JSON block now with success=false. Example sentinel: {\"success\": false, \"reason\": \"no CI checks configured\"}"
    },
    "check_repo_merge_state": {
      "tool": "check_repo_merge_state",
      "block": "pre_queue_gate",
      "with": {
        "branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "step_name": "check_repo_merge_state",
        "base_branch": "${{ inputs.base_branch }}"
      },
      "capture": {
        "queue_available": "${{ result.queue_available }}",
        "merge_group_trigger": "${{ result.merge_group_trigger }}",
        "auto_merge_available": "${{ result.auto_merge_available }}",
        "ci_event": "${{ result.ci_event }}",
        "ci_applicable": "${{ result.ci_applicable }}"
      },
      "on_success": "route_queue_mode",
      "on_failure": "immediate_merge",
      "skip_when_false": "inputs.open_pr",
      "note": "Single GraphQL round-trip that captures queue_available, merge_group_trigger, auto_merge_available, and ci_event for the target branch. Consolidates the former three sequential run_cmd steps (check_merge_queue, check_merge_group_trigger, check_auto_merge) into one MCP tool call. On failure (network error, auth failure), falls through to immediate_merge (non-queue direct merge path). Skipped when open_pr=false — no PR was opened.\n"
    },
    "route_queue_mode": {
      "block": "pre_queue_gate",
      "action": "route",
      "on_result": [
        {
          "when": "${{ inputs.auto_merge }} != 'true'",
          "route": "patch_token_summary"
        },
        {
          "when": "${{ context.queue_available }} == true and ${{ context.merge_group_trigger }} == true",
          "route": "enqueue_to_queue"
        },
        {
          "when": "${{ context.auto_merge_available }} == true",
          "route": "direct_merge"
        },
        {
          "route": "immediate_merge"
        }
      ],
      "skip_when_false": "inputs.open_pr"
    },
    "enqueue_to_queue": {
      "tool": "enqueue_pr",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "auto_merge_available": "${{ context.auto_merge_available }}"
      },
      "on_success": "wait_for_queue",
      "on_failure": "verify_queue_enrollment",
      "skip_when_false": "inputs.open_pr",
      "note": "Submits the PR to the merge queue via the unified enqueue_pr tool. The tool resolves the enrollment strategy internally based on auto_merge_available. On failure, probes the queue via verify_queue_enrollment to distinguish a transient enqueue error from a PR that is already merged or still in queue.\n"
    },
    "verify_queue_enrollment": {
      "description": "Probe merge queue after enqueue command failure to determine actual state",
      "tool": "wait_for_merge_queue",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "auto_merge_available": "${{ context.auto_merge_available }}",
        "timeout_seconds": 60,
        "poll_interval": 10,
        "max_merge_group_drops": 1
      },
      "on_result": [
        {
          "when": "${{ result.pr_state }} == merged",
          "route": "release_issue_success"
        },
        {
          "when": "${{ result.pr_state }} == ejected_ci_failure",
          "route": "diagnose_ci"
        },
        {
          "when": "${{ result.pr_state }} == not_enrolled",
          "route": "release_issue_failure"
        },
        {
          "when": "${{ result.pr_state }} == dropped_healthy",
          "route": "wait_for_queue"
        },
        {
          "when": "${{ result.pr_state }} == dropped_merge_group_ci",
          "route": "diagnose_ci"
        },
        {
          "when": "${{ result.pr_state }} == ejected",
          "route": "wait_for_queue"
        },
        {
          "when": "${{ result.pr_state }} == stalled",
          "route": "wait_for_queue"
        },
        {
          "when": "${{ result.pr_state }} == timeout",
          "route": "register_clone_unconfirmed"
        },
        {
          "route": "register_clone_unconfirmed"
        }
      ],
      "on_failure": "register_clone_unconfirmed",
      "note": "Short probe (60s) after enqueue_to_queue failure. If the PR is already merged, route to release_issue_success. If the queue already confirms CI failure (ejected_ci_failure or dropped_merge_group_ci), route directly to diagnose_ci. If enrollment was attempted but the PR never appeared in the queue (not_enrolled), route to release_issue_failure — this is a repo configuration error. For other active queue states (dropped_healthy, ejected, stalled), route to wait_for_queue for full 900s authoritative watch. If the probe timed out or returned an unexpected state, escalate via register_clone_unconfirmed.\n"
    },
    "wait_for_queue": {
      "tool": "wait_for_merge_queue",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "timeout_seconds": 900,
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "auto_merge_available": "${{ context.auto_merge_available }}",
        "max_merge_group_drops": 1
      },
      "capture": {
        "queue_pr_state": "${{ result.pr_state }}"
      },
      "on_result": [
        {
          "when": "${{ result.pr_state }} == merged",
          "route": "release_issue_success"
        },
        {
          "when": "${{ result.pr_state }} == ejected_ci_failure",
          "route": "diagnose_ci"
        },
        {
          "when": "${{ result.pr_state }} == dropped_merge_group_ci",
          "route": "check_dropped_ci_loop"
        },
        {
          "when": "${{ result.pr_state }} == not_enrolled",
          "route": "release_issue_failure"
        },
        {
          "when": "${{ result.pr_state }} == dropped_healthy",
          "route": "check_dropped_healthy_loop"
        },
        {
          "when": "${{ result.pr_state }} == ejected",
          "route": "check_eject_limit"
        },
        {
          "when": "${{ result.pr_state }} == stalled",
          "route": "reenroll_stalled_pr"
        },
        {
          "when": "${{ result.pr_state }} == timeout",
          "route": "register_clone_unconfirmed"
        },
        {
          "route": "register_clone_unconfirmed"
        }
      ],
      "on_failure": "register_clone_unconfirmed",
      "skip_when_false": "inputs.open_pr",
      "note": "Waits up to 15 minutes for the PR to merge through the queue. merged → release_issue_success to transition issue state then register_clone_success. ejected_ci_failure → diagnose_ci (CI failure; conflict resolution cannot fix this). dropped_merge_group_ci → check_dropped_ci_loop (re-enqueue on first drop, escalate to diagnose_ci after the cap is exceeded). not_enrolled → release_issue_failure (enrollment failed; repo configuration error). ejected → conflict fix cycle then re-enter. stalled → lightweight re-enrollment via enqueue_pr. timeout → register_clone_unconfirmed (release claim without staged label; merge unconfirmed).\n"
    },
    "reenroll_stalled_pr": {
      "tool": "enqueue_pr",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "auto_merge_available": "${{ context.auto_merge_available }}"
      },
      "on_success": "check_stall_loop",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr"
    },
    "check_stall_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.stall_loop_count }}",
        "max_iterations": "3"
      },
      "capture": {
        "stall_loop_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "register_clone_unconfirmed"
        },
        {
          "route": "wait_for_queue"
        }
      ],
      "on_failure": "register_clone_unconfirmed",
      "optional_context_refs": [
        "stall_loop_count"
      ],
      "note": "Iteration guard for the wait_for_queue / reenroll_stalled_pr cycle. Caps stall re-enrollment at 3 attempts. On budget exhaustion, routes to register_clone_unconfirmed (merge outcome unconfirmed).\n"
    },
    "check_eject_limit": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.check_eject_limit",
        "counter_file": "${{ context.work_dir }}/{{AUTOSKILLIT_TEMP}}/eject_count",
        "max_ejects": "3"
      },
      "on_result": [
        {
          "when": "${{ result.status }} == EJECT_LIMIT_EXCEEDED",
          "route": "release_issue_failure"
        },
        {
          "route": "queue_ejected_fix"
        }
      ],
      "on_failure": "release_issue_failure",
      "note": "Circuit breaker for the queue ejection loop. Tracks ejection count in a file-based counter under {{AUTOSKILLIT_TEMP}}/. After 3 ejections, routes to release_issue_failure to prevent infinite re-enqueue cycles.\n"
    },
    "check_dropped_healthy_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.check_dropped_healthy_loop",
        "counter_file": "${{ context.work_dir }}/{{AUTOSKILLIT_TEMP}}/dropped_healthy_count",
        "max_drops": "2"
      },
      "on_result": [
        {
          "when": "${{ result.status }} == DROPPED_LIMIT_EXCEEDED",
          "route": "release_issue_failure"
        },
        {
          "route": "reenter_merge_queue_cheap"
        }
      ],
      "on_failure": "release_issue_failure",
      "note": "Circuit breaker for the dropped_healthy re-enrollment loop. After 2 consecutive unexplained drops with healthy PR-branch CI, escalates to release_issue_failure instead of looping. Matches the check_eject_limit pattern used for the ejected path. DROPPED_MERGE_GROUP_CI (confirmed merge-group CI failure) is routed through check_dropped_ci_loop instead and never reaches this step.\n"
    },
    "check_dropped_ci_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.check_dropped_ci_loop",
        "counter_file": "${{ context.work_dir }}/{{AUTOSKILLIT_TEMP}}/dropped_ci_count",
        "max_drops": "2"
      },
      "on_result": [
        {
          "when": "${{ result.status }} == DROPPED_CI_LIMIT_EXCEEDED",
          "route": "diagnose_ci"
        },
        {
          "route": "reenter_merge_queue_cheap"
        }
      ],
      "on_failure": "diagnose_ci",
      "note": "Circuit breaker for the dropped_merge_group_ci re-enrollment loop. Tracks merge-group-CI drop count in a file-based counter. On the first drop, re-enqueues via reenter_merge_queue_cheap (transient CI failure is often self-healing). After 2 consecutive drops, escalates to diagnose_ci — the merge-group CI is persistently failing, so a re-enqueue is unlikely to help. Mirrors the check_dropped_healthy_loop pattern for the dropped_healthy branch.\n"
    },
    "queue_ejected_fix": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.queue_ejected_fix",
        "args": {
          "work_dir": "${{ context.work_dir }}",
          "base_branch": "${{ inputs.base_branch }}"
        }
      },
      "on_result": [
        {
          "when": "${{ result.status }} == clean",
          "route": "re_push_queue_fix"
        },
        {
          "route": "resolve_queue_merge_conflicts"
        }
      ],
      "on_failure": "resolve_queue_merge_conflicts",
      "skip_when_false": "inputs.open_pr",
      "note": "Attempts a cheap rebase before invoking the full conflict-resolution skill. On a clean rebase (stdout \"clean\"), skips the skill and proceeds directly to re_push_queue_fix. On conflict, aborts the rebase and routes to resolve_queue_merge_conflicts for goal-aware resolution.\n"
    },
    "resolve_queue_merge_conflicts": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_queue_merge_conflicts"
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "diagnose_ci"
        },
        {
          "route": "re_push_queue_fix"
        }
      ],
      "on_failure": "diagnose_ci",
      "on_context_limit": "diagnose_ci",
      "retries": 1,
      "on_exhausted": "diagnose_ci",
      "skip_when_false": "inputs.open_pr",
      "note": "Resolves rebase conflicts on the feature branch after queue ejection. Only reached when the cheap rebase in queue_ejected_fix encountered conflicts. escalation_required=true → release_issue_failure for human review.\n"
    },
    "re_push_queue_fix": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "capture": {
        "push_error_type": "${{ result.error_type }}"
      },
      "retries": 2,
      "on_exhausted": "register_clone_unconfirmed",
      "on_success": "ci_watch_post_queue_fix",
      "on_failure": "classify_push_failure",
      "skip_when_false": "inputs.open_pr"
    },
    "classify_push_failure": {
      "action": "route",
      "on_result": [
        {
          "when": "${{ context.push_error_type }} == queued_branch",
          "route": "wait_dequeue_retry"
        },
        {
          "route": "release_issue_failure"
        }
      ]
    },
    "wait_dequeue_retry": {
      "tool": "wait_for_merge_queue",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "auto_merge_available": "${{ context.auto_merge_available }}",
        "timeout_seconds": "60",
        "max_merge_group_drops": "1"
      },
      "on_result": [
        {
          "when": "${{ result.pr_state }} == merged",
          "route": "release_issue_success"
        },
        {
          "when": "${{ result.pr_state }} == ejected_ci_failure",
          "route": "register_clone_unconfirmed"
        },
        {
          "when": "${{ result.pr_state }} == dropped_merge_group_ci",
          "route": "register_clone_unconfirmed"
        },
        {
          "when": "${{ result.pr_state }} == dropped_healthy",
          "route": "register_clone_unconfirmed"
        },
        {
          "when": "${{ result.pr_state }} == ejected",
          "route": "re_push_queue_fix"
        },
        {
          "when": "${{ result.pr_state }} == stalled",
          "route": "register_clone_unconfirmed"
        },
        {
          "when": "${{ result.pr_state }} == timeout",
          "route": "register_clone_unconfirmed"
        },
        {
          "route": "register_clone_unconfirmed"
        }
      ],
      "on_failure": "register_clone_unconfirmed",
      "optional_context_refs": [
        "push_error_type"
      ]
    },
    "ci_watch_post_queue_fix": {
      "tool": "wait_for_ci",
      "with": {
        "branch": "${{ context.merge_target }}",
        "event": "${{ context.ci_event }}",
        "timeout_seconds": 600,
        "cwd": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "auto_trigger": true
      },
      "capture": {
        "ci_conclusion": "${{ result.conclusion }}",
        "ci_failed_jobs": "${{ result.failed_jobs }}"
      },
      "on_result": [
        {
          "when": "${{ result.conclusion }} == 'success'",
          "route": "reenter_merge_queue"
        },
        {
          "when": "${{ result.conclusion }} == 'no_runs'",
          "route": "release_issue_failure"
        },
        {
          "when": "${{ result.conclusion }} == 'timed_out'",
          "route": "check_ci_post_queue_loop"
        },
        {
          "route": "detect_ci_conflict"
        }
      ],
      "on_failure": "detect_ci_conflict",
      "skip_when_false": "inputs.open_pr",
      "note": "Validates CI on the rebased feature branch after queue ejection fix and re-push. Routes on result.conclusion: success → reenter_merge_queue, no_runs → release_issue_failure (auto_trigger fires first: empty commit + force-push + re-poll; no_runs reached only when trigger recovery fails), timed_out → check_ci_post_queue_loop, failure → detect_ci_conflict.\n"
    },
    "check_ci_post_queue_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.ci_post_queue_loop_count }}",
        "max_iterations": "2"
      },
      "capture": {
        "ci_post_queue_loop_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "ci_watch_post_queue_fix"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "ci_post_queue_loop_count"
      ],
      "skip_when_false": "inputs.open_pr",
      "note": "Iteration guard for the ci_watch_post_queue_fix timed_out self-loop. Caps at 2 iterations (initial + 1 retry). On budget exhaustion, routes to release_issue_failure — this is already a post-ejection retry path so further escalation is not warranted.\n"
    },
    "reenter_merge_queue": {
      "tool": "enqueue_pr",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "auto_merge_available": "${{ context.auto_merge_available }}"
      },
      "on_success": "wait_for_queue",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr",
      "note": "Re-submits the PR after conflict resolution. Routes back to wait_for_queue. If re-entry fails, release_issue_failure preserves the clone for debugging.\n"
    },
    "reenter_merge_queue_cheap": {
      "tool": "enqueue_pr",
      "with": {
        "pr_number": "${{ context.pr_number }}",
        "target_branch": "${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "auto_merge_available": "${{ context.auto_merge_available }}"
      },
      "on_success": "wait_for_queue",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr",
      "note": "Re-submits a healthy PR into the merge queue after auto_merge was cleared externally (DROPPED_HEALTHY state). No conflict-resolution CI wait needed. Routes back to wait_for_queue on success.\n"
    },
    "direct_merge": {
      "tool": "run_cmd",
      "with": {
        "cmd": "gh pr merge '${{ context.pr_number }}' --squash --auto",
        "cwd": "${{ context.work_dir }}",
        "step_name": "direct_merge"
      },
      "on_success": "wait_for_direct_merge",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr",
      "note": "Enables GitHub native auto-merge for direct merge (no merge queue). GitHub merges automatically once all required checks pass. On failure, escalates via release_issue_failure so the issue claim is released and the pipeline reports an error rather than silently succeeding.\n"
    },
    "wait_for_direct_merge": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.wait_for_direct_merge",
        "pr_number": "${{ context.pr_number }}",
        "max_polls": "90",
        "poll_interval": "10"
      },
      "on_result": [
        {
          "when": "${{ result.state }} == merged",
          "route": "release_issue_success"
        },
        {
          "when": "${{ result.state }} == closed",
          "route": "direct_merge_conflict_fix"
        },
        {
          "route": "register_clone_unconfirmed"
        }
      ],
      "on_failure": "register_clone_unconfirmed",
      "skip_when_false": "inputs.open_pr",
      "note": "Polls GitHub PR state every 10 s for up to 15 minutes (90 iterations). merged → release_issue_success (issue labelled, cleanup runs). closed → PR was closed (likely conflict) — route to conflict fix. timeout / unexpected → register_clone_unconfirmed.\n"
    },
    "direct_merge_conflict_fix": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.direct_merge_conflict_fix",
        "args": {
          "work_dir": "${{ context.work_dir }}",
          "base_branch": "${{ inputs.base_branch }}"
        }
      },
      "on_result": [
        {
          "when": "${{ result.status }} == clean",
          "route": "re_push_direct_fix"
        },
        {
          "route": "resolve_direct_merge_conflicts"
        }
      ],
      "on_failure": "resolve_direct_merge_conflicts",
      "skip_when_false": "inputs.open_pr",
      "note": "Attempts a cheap rebase before invoking the full conflict-resolution skill. On clean rebase, proceeds to re_push_direct_fix. On conflict, routes to resolve_direct_merge_conflicts for goal-aware resolution.\n"
    },
    "resolve_direct_merge_conflicts": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_direct_merge_conflicts"
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "diagnose_ci"
        },
        {
          "route": "re_push_direct_fix"
        }
      ],
      "on_failure": "diagnose_ci",
      "on_context_limit": "diagnose_ci",
      "retries": 1,
      "on_exhausted": "diagnose_ci",
      "skip_when_false": "inputs.open_pr",
      "note": "Resolves rebase conflicts after direct-merge rejection. Only reached when the cheap rebase in direct_merge_conflict_fix encountered conflicts. escalation_required=true → release_issue_failure for human review.\n"
    },
    "re_push_direct_fix": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "redirect_merge",
      "on_failure": "classify_push_failure",
      "skip_when_false": "inputs.open_pr"
    },
    "redirect_merge": {
      "tool": "run_cmd",
      "with": {
        "cmd": "gh pr merge '${{ context.pr_number }}' --squash --auto",
        "cwd": "${{ context.work_dir }}",
        "step_name": "redirect_merge"
      },
      "on_success": "wait_for_direct_merge",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr",
      "note": "Re-enables auto-merge after conflict resolution and re-push. Routes back to wait_for_direct_merge to poll for completion. On failure, release_issue_failure preserves the clone for debugging.\n"
    },
    "immediate_merge": {
      "tool": "run_cmd",
      "with": {
        "cmd": "gh pr merge '${{ context.pr_number }}' --squash",
        "cwd": "${{ context.work_dir }}",
        "step_name": "immediate_merge"
      },
      "on_success": "wait_for_immediate_merge",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr",
      "note": "Merges the PR immediately using plain --squash when autoMergeAllowed=false. Unlike direct_merge, no --auto flag is used — GitHub executes the merge synchronously rather than queueing it for when checks pass. On failure, escalates via release_issue_failure so the issue claim is released and the pipeline reports an error rather than silently succeeding.\n"
    },
    "wait_for_immediate_merge": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.wait_for_immediate_merge",
        "pr_number": "${{ context.pr_number }}",
        "max_polls": "30",
        "poll_interval": "10"
      },
      "on_result": [
        {
          "when": "${{ result.state }} == merged",
          "route": "release_issue_success"
        },
        {
          "when": "${{ result.state }} == closed",
          "route": "immediate_merge_conflict_fix"
        },
        {
          "route": "register_clone_unconfirmed"
        }
      ],
      "on_failure": "register_clone_unconfirmed",
      "skip_when_false": "inputs.open_pr",
      "note": "Polls GitHub PR state every 10s for up to 5 minutes (30 iterations). Since immediate_merge uses --squash without --auto, the merge completes synchronously — this poll is a confirmation window. merged → release_issue_success. closed → PR was rejected (stale base or conflict) — route to conflict fix. timeout → register_clone_unconfirmed.\n"
    },
    "immediate_merge_conflict_fix": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.immediate_merge_conflict_fix",
        "args": {
          "work_dir": "${{ context.work_dir }}",
          "base_branch": "${{ inputs.base_branch }}"
        }
      },
      "on_result": [
        {
          "when": "${{ result.status }} == clean",
          "route": "re_push_immediate_fix"
        },
        {
          "route": "resolve_immediate_merge_conflicts"
        }
      ],
      "on_failure": "resolve_immediate_merge_conflicts",
      "skip_when_false": "inputs.open_pr",
      "note": "Attempts a cheap rebase before invoking the full conflict-resolution skill. On clean rebase, proceeds to re_push_immediate_fix. On conflict, routes to resolve_immediate_merge_conflicts for goal-aware resolution.\n"
    },
    "resolve_immediate_merge_conflicts": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_immediate_merge_conflicts"
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "diagnose_ci"
        },
        {
          "route": "re_push_immediate_fix"
        }
      ],
      "on_failure": "diagnose_ci",
      "on_context_limit": "diagnose_ci",
      "retries": 1,
      "on_exhausted": "diagnose_ci",
      "skip_when_false": "inputs.open_pr",
      "note": "Resolves rebase conflicts after immediate-merge rejection. Only reached when the cheap rebase in immediate_merge_conflict_fix encountered conflicts. escalation_required=true → release_issue_failure for human review.\n"
    },
    "re_push_immediate_fix": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "remerge_immediate",
      "on_failure": "classify_push_failure",
      "skip_when_false": "inputs.open_pr"
    },
    "remerge_immediate": {
      "tool": "run_cmd",
      "with": {
        "cmd": "gh pr merge '${{ context.pr_number }}' --squash",
        "cwd": "${{ context.work_dir }}",
        "step_name": "remerge_immediate"
      },
      "on_success": "wait_for_immediate_merge",
      "on_failure": "release_issue_failure",
      "skip_when_false": "inputs.open_pr",
      "note": "Re-attempts plain squash merge after conflict resolution and re-push. Routes back to wait_for_immediate_merge to confirm completion. On failure, release_issue_failure preserves the clone for debugging.\n"
    },
    "diagnose_ci": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:diagnose-ci ${{ context.merge_target }} - - - ${{ context.ci_event }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "diagnose_ci",
        "ci_failed_jobs": "${{ context.ci_failed_jobs }}",
        "output_dir": "{{AUTOSKILLIT_TEMP}}/diagnose-ci"
      },
      "capture": {
        "diagnosis_path": "${{ result.diagnosis_path }}"
      },
      "on_success": "resolve_ci",
      "on_failure": "resolve_ci",
      "on_context_limit": "resolve_ci",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "Runs when ci_watch reports a CI failure. Fetches CI logs via gh API and writes a structured diagnosis to {{AUTOSKILLIT_TEMP}}/diagnose-ci/. Routes to resolve_ci on success OR failure. If diagnosis fails, resolve_ci proceeds without diagnosis context. diagnosis_path is passed to resolve_ci for targeted remediation context.\n"
    },
    "resolve_ci": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-failures ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }} ${{ context.ci_conclusion }} ${{ context.ci_failed_jobs }} ${{ context.diagnosis_path }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_ci"
      },
      "capture": {
        "verdict": "${{ result.verdict }}"
      },
      "retries": 2,
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write",
      "on_exhausted": "release_issue_failure",
      "on_context_limit": "release_issue_failure",
      "on_result": [
        {
          "when": "${{ result.verdict }} == 'real_fix'",
          "route": "re_push"
        },
        {
          "when": "${{ result.verdict }} == 'already_green'",
          "route": "pre_resolve_rebase"
        },
        {
          "when": "${{ result.verdict }} == 'flake_suspected'",
          "route": "check_flake_loop"
        },
        {
          "when": "${{ result.verdict }} == 'ci_only_failure'",
          "route": "release_issue_failure"
        },
        {
          "when": "${{ result.verdict }} == 'no_test_infrastructure'",
          "route": "release_issue_failure"
        },
        {
          "route": "release_issue_failure"
        }
      ],
      "on_failure": "release_issue_failure",
      "note": "Runs when ci_watch reports a CI failure. Receives ci_failed_jobs from wait_for_ci structured output to avoid redundant CI failure re-investigation. Routes via on_result: verdict dispatch — real_fix pushes, already_green rebases and re-diagnoses (sibling fix may have landed), flake_suspected routes to check_flake_loop (bounded by ci_flake_count <= 3, shared across all diagnose_ci callers; escalates to release_issue_failure when exceeded), ci_only_failure escalates to human. Retries up to 2 times (3 total attempts) before exhausting to release_issue_failure.\n"
    },
    "pre_resolve_rebase": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.recipe._cmd_rpc.review_path_rebase",
        "args": {
          "work_dir": "${{ context.work_dir }}",
          "base_branch": "${{ inputs.base_branch }}"
        }
      },
      "on_result": [
        {
          "when": "${{ result.status }} == clean",
          "route": "check_ci_rebase_loop"
        },
        {
          "route": "resolve_pre_resolve_conflicts"
        }
      ],
      "on_failure": "resolve_pre_resolve_conflicts",
      "note": "Rebases the feature branch against integration head when resolve_ci emits already_green — the worktree was already clean because a sibling pipeline's fix already landed on integration. Pulling it in before re-running diagnose_ci gives the pipeline a real chance at emitting real_fix and reaching re_push.\n"
    },
    "resolve_pre_resolve_conflicts": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "resolve_pre_resolve_conflicts"
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "optional": true,
      "skip_when_false": "inputs.backend_supports_git_write",
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "diagnose_ci"
        },
        {
          "route": "check_ci_rebase_loop"
        }
      ],
      "on_failure": "diagnose_ci",
      "on_context_limit": "diagnose_ci",
      "retries": 1,
      "on_exhausted": "diagnose_ci"
    },
    "check_ci_rebase_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.ci_rebase_count }}",
        "max_iterations": "3"
      },
      "capture": {
        "ci_rebase_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "diagnose_ci"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "ci_rebase_count"
      ],
      "note": "Guards the resolve_ci(already_green) → pre_resolve_rebase → diagnose_ci cycle. Caps at 3 rebase-rediagnose iterations. If CI keeps reporting already_green after 3 rebases, a structural issue requires human intervention.\n"
    },
    "check_flake_loop": {
      "tool": "run_python",
      "with": {
        "callable": "autoskillit.smoke_utils.check_loop_iteration",
        "current_iteration": "${{ context.ci_flake_count }}",
        "max_iterations": "3"
      },
      "capture": {
        "ci_flake_count": "${{ result.next_iteration }}"
      },
      "on_result": [
        {
          "when": "${{ result.max_exceeded }} == true",
          "route": "release_issue_failure"
        },
        {
          "route": "re_push"
        }
      ],
      "on_failure": "release_issue_failure",
      "optional_context_refs": [
        "ci_flake_count"
      ],
      "note": "Guards ALL resolve_ci(flake_suspected) → re_push cycles. The ci_flake_count counter is shared across all entry points into diagnose_ci, including CI watch retries, merge queue ejections, dropped-CI-group paths, and conflict resolution escalations. Caps at 3 total flake_suspected verdicts per pipeline run. If CI keeps failing with the same flake_suspected verdict after 3 iterations from any combination of callers, the failure requires human intervention.\n"
    },
    "re_push": {
      "tool": "push_to_remote",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "remote_url": "${{ context.remote_url }}",
        "branch": "${{ context.merge_target }}",
        "force": "true"
      },
      "on_success": "check_repo_ci_event",
      "on_failure": "classify_push_failure",
      "note": "Pushes the CI-fixed feature branch back to the remote after resolve_ci succeeds. Routes to check_repo_ci_event to derive ci_event before ci_watch verifies the fix. On push failure, escalates via release_issue_failure.\n"
    },
    "detect_ci_conflict": {
      "tool": "run_cmd",
      "with": {
        "cmd": "REMOTE=$(git remote get-url upstream 2>/dev/null | grep -qv \"^file://\" && echo upstream || echo origin) &&\ngit fetch \"$REMOTE\" ${{ inputs.base_branch }} &&\n! git merge-base --is-ancestor \"$REMOTE\"/${{ inputs.base_branch }} HEAD\n",
        "cwd": "${{ context.work_dir }}",
        "step_name": "detect_ci_conflict"
      },
      "on_success": "ci_conflict_fix",
      "on_failure": "diagnose_ci",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "note": "Stale-base triage gate for CI FAILURE paths only. Do NOT route check_pr_mergeable CONFLICTING here — GitHub's CONFLICTING status is authoritative and should route directly to ci_conflict_fix. Valid callers: ci_watch, check_ci_timed_out_loop, check_ci_already_passed, ci_watch_post_queue_fix. Exit 0 (base NOT ancestor) → ci_conflict_fix. Exit 1 (base IS ancestor or fetch failed) → diagnose_ci.\n"
    },
    "ci_conflict_fix": {
      "tool": "run_skill",
      "model": "",
      "with": {
        "skill_command": "/autoskillit:resolve-merge-conflicts ${{ context.work_dir }} ${{ context.plan_path }} ${{ inputs.base_branch }}",
        "cwd": "${{ context.work_dir }}",
        "output_dir": ".",
        "step_name": "ci_conflict_fix"
      },
      "capture": {
        "conflict_escalation_required": "${{ result.escalation_required }}"
      },
      "on_result": [
        {
          "when": "${{ result.escalation_required }} == true",
          "route": "diagnose_ci"
        },
        {
          "route": "re_push"
        }
      ],
      "on_failure": "diagnose_ci",
      "on_context_limit": "diagnose_ci",
      "retries": 1,
      "on_exhausted": "diagnose_ci",
      "skip_when_false": "inputs.open_pr",
      "note": "Resolves a stale-base CI failure by rebasing the feature branch onto the latest integration HEAD. Mirrors queue_ejected_fix: on clean rebase or goal-aware conflict resolution, routes to re_push to re-trigger CI on the rebased branch. On escalation (LOW confidence conflicts), tool failure, context limit, or retry exhaustion, routes to diagnose_ci for CI log capture before release_issue_failure. diagnose_ci runs before resolve_ci. If diagnosis fails, resolve_ci proceeds without diagnosis context. retries: 1 bounds the loop; after 2 total attempts, escalates.\n"
    },
    "release_issue_success": {
      "description": "Transition issue from in-progress to staged after successful pipeline completion",
      "tool": "release_issue",
      "optional": true,
      "skip_when_false": "inputs.issue_url",
      "with": {
        "issue_url": "${{ inputs.issue_url }}",
        "target_branch": "${{ inputs.base_branch }}"
      },
      "on_success": "patch_token_summary",
      "on_failure": "patch_token_summary",
      "note": "Called on the success path after PR merge is confirmed. Passes target_branch so release_issue can determine whether to apply the staged label (non-default target) or just remove in-progress (default target). Pipeline routes to register_clone_success on both success and failure.\n"
    },
    "patch_token_summary": {
      "description": "Collect all pipeline token data and patch the PR body with complete summary",
      "tool": "run_python",
      "optional": true,
      "skip_when_false": "inputs.open_pr",
      "with": {
        "callable": "autoskillit.smoke_utils.patch_pr_token_summary",
        "timeout": 60,
        "pr_url": "${{ context.pr_url }}",
        "cwd": "${{ context.work_dir }}"
      },
      "on_success": "register_clone_success",
      "on_failure": "register_clone_success",
      "note": "Patches PR body with complete token summary; failures are logged but do not alter pipeline routing.\n"
    },
    "register_clone_unconfirmed": {
      "description": "Register clone as preserved — merge unconfirmed, in-progress label retained",
      "tool": "register_clone_status",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "status": "unconfirmed",
        "step_name": "register_clone_unconfirmed"
      },
      "on_success": "run_diagnostic_unconfirmed",
      "on_failure": "run_diagnostic_unconfirmed",
      "note": "Called when a merge-wait step times out before merge is confirmed. Does NOT call release_issue — the in-progress label stays on the issue so operators can see the PR is still actively queued. The clone is preserved (status: unconfirmed) for human inspection.\n"
    },
    "run_diagnostic_unconfirmed": {
      "description": "Run post-pipeline diagnostic analysis on session logs (unconfirmed path)",
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "optional": true,
      "skip_when_false": "inputs.post_run_diagnostics",
      "with": {
        "skill_command": "/autoskillit:analyze-pipeline-health ${{ inputs.kitchen_id }} --dispatch-id=${{ inputs.dispatch_id }} --diagnostics-log-dir=${{ inputs.diagnostics_log_dir }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "post_run_diagnostics"
      },
      "on_success": "done_unconfirmed",
      "on_failure": "done_unconfirmed",
      "on_context_limit": "done_unconfirmed",
      "note": "Execute this diagnostic step. Failures are logged but do not alter pipeline routing.\n"
    },
    "done_unconfirmed": {
      "action": "stop",
      "message": "Implementation pipeline finished but merge was not confirmed within the timeout window. The PR is still open and the clone has been preserved for inspection. The in-progress label remains on the issue. Human operator should verify merge status. Emit the L3 result sentinel JSON block now with success=true and reason=\"merge_unconfirmed\". Example sentinel: {\"success\": true, \"reason\": \"merge_unconfirmed\"}"
    },
    "release_issue_failure": {
      "description": "Release the in-progress claim after pipeline failure",
      "tool": "release_issue",
      "optional": true,
      "skip_when_false": "inputs.issue_url",
      "with": {
        "issue_url": "${{ inputs.issue_url }}",
        "fail_label": "fail"
      },
      "on_success": "register_clone_failure",
      "on_failure": "register_clone_failure"
    },
    "register_clone_success": {
      "description": "Register clone as cleanup candidate for batch deletion",
      "tool": "register_clone_status",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "status": "success",
        "step_name": "register_clone_success"
      },
      "on_success": "run_diagnostic",
      "on_failure": "run_diagnostic"
    },
    "register_clone_failure": {
      "description": "Register clone as preserved (error pipeline)",
      "tool": "register_clone_status",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "status": "error",
        "step_name": "register_clone_failure"
      },
      "on_success": "run_diagnostic_error",
      "on_failure": "run_diagnostic_error"
    },
    "run_diagnostic": {
      "description": "Run post-pipeline diagnostic analysis on session logs",
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "optional": true,
      "skip_when_false": "inputs.post_run_diagnostics",
      "with": {
        "skill_command": "/autoskillit:analyze-pipeline-health ${{ inputs.kitchen_id }} --dispatch-id=${{ inputs.dispatch_id }} --diagnostics-log-dir=${{ inputs.diagnostics_log_dir }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "post_run_diagnostics"
      },
      "on_success": "done",
      "on_failure": "done",
      "on_context_limit": "done",
      "note": "Execute this diagnostic step. Failures are logged but do not alter pipeline routing. Both on_failure and on_context_limit route to the same terminal as on_success.\n"
    },
    "run_diagnostic_error": {
      "description": "Run post-pipeline diagnostic analysis on session logs (error path)",
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "optional": true,
      "skip_when_false": "inputs.post_run_diagnostics",
      "with": {
        "skill_command": "/autoskillit:analyze-pipeline-health ${{ inputs.kitchen_id }} --dispatch-id=${{ inputs.dispatch_id }} --diagnostics-log-dir=${{ inputs.diagnostics_log_dir }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "post_run_diagnostics"
      },
      "on_success": "escalate_stop",
      "on_failure": "escalate_stop",
      "on_context_limit": "escalate_stop",
      "note": "Execute this diagnostic step. Failures are logged but do not alter pipeline routing.\n"
    },
    "register_clone_no_changes": {
      "description": "Register clone as cleanup candidate (zero-change path)",
      "tool": "register_clone_status",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "status": "success",
        "step_name": "register_clone_no_changes"
      },
      "on_success": "run_diagnostic_no_changes",
      "on_failure": "run_diagnostic_no_changes"
    },
    "run_diagnostic_no_changes": {
      "description": "Run post-pipeline diagnostic analysis (zero-change path)",
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "optional": true,
      "skip_when_false": "inputs.post_run_diagnostics",
      "with": {
        "skill_command": "/autoskillit:analyze-pipeline-health ${{ inputs.kitchen_id }} --dispatch-id=${{ inputs.dispatch_id }} --diagnostics-log-dir=${{ inputs.diagnostics_log_dir }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "post_run_diagnostics"
      },
      "on_success": "done_no_changes",
      "on_failure": "done_no_changes",
      "on_context_limit": "done_no_changes",
      "note": "Execute this diagnostic step. Failures are logged but do not alter pipeline routing.\n"
    },
    "register_clone_already_done": {
      "description": "Register clone as cleanup candidate (already-done path)",
      "tool": "register_clone_status",
      "with": {
        "clone_path": "${{ context.work_dir }}",
        "status": "success",
        "step_name": "register_clone_already_done"
      },
      "on_success": "run_diagnostic_already_done",
      "on_failure": "run_diagnostic_already_done"
    },
    "run_diagnostic_already_done": {
      "description": "Run post-pipeline diagnostic analysis (already-done path)",
      "tool": "run_skill",
      "model": "",
      "stale_threshold": 2400,
      "optional": true,
      "skip_when_false": "inputs.post_run_diagnostics",
      "with": {
        "skill_command": "/autoskillit:analyze-pipeline-health ${{ inputs.kitchen_id }} --dispatch-id=${{ inputs.dispatch_id }} --diagnostics-log-dir=${{ inputs.diagnostics_log_dir }}",
        "cwd": "${{ context.work_dir }}",
        "step_name": "post_run_diagnostics"
      },
      "on_success": "done_already_done",
      "on_failure": "done_already_done",
      "on_context_limit": "done_already_done",
      "note": "Execute this diagnostic step. Failures are logged but do not alter pipeline routing.\n"
    },
    "done": {
      "action": "stop",
      "message": "Implementation pipeline complete. All tasks have been planned, implemented, tested, and merged. Emit the L3 result sentinel JSON block now with success=true. Example sentinel: {\"success\": true, \"reason\": \"implementation_complete\"}"
    },
    "done_no_changes": {
      "action": "stop",
      "message": "Pipeline completed with zero changes — the implement step produced no commits. Emit the L3 result sentinel JSON block now with success=true and reason=\"no_changes\". Example sentinel: {\"success\": true, \"reason\": \"no_changes\"}"
    },
    "done_already_done": {
      "action": "stop",
      "message": "Pipeline completed — changes were already merged by a prior run. Emit the L3 result sentinel JSON block now with success=true and reason=\"already_done\". Example sentinel: {\"success\": true, \"reason\": \"already_done\"}"
    },
    "escalate_stop": {
      "action": "stop",
      "message": "Pipeline failed — human intervention needed. Check the worktree and plan for details. Emit the L3 result sentinel JSON block now with success=false. Example sentinel: {\"success\": false, \"reason\": \"implementation pipeline failed\"}"
    }
  }
}