pr-lifecycle-agent

interface PRResult {
  success: boolean;
  pr_number: number;
  pr_url: string;
  pr_status: 'open' | 'merged' | 'closed';
  review_comments: ReviewComment[];
  // Step 3 outcome. Only 'reviewed' may proceed silently; the others MUST be logged AND recorded
  // in the PR body. 'unknown' is never a pass (undet:fail). 'not-configured' means the pre-check
  // proved the repo has no AI reviewer, so the wait was skipped — not applicable, not a pass.
  review_wait: 'reviewed' | 'none-posted' | 'unknown' | 'not-configured';
  ci_status: 'passed' | 'failed' | 'pending' | 'blocked';   // 'blocked' = ci_exhausted / ci_wait_cap
  // Step 6 wall-clock accounting — cap derived per skills/job-timeout-budget; logged on join.
  ci_wait?: {
    cap_minutes: number;      // max(job-level timeout-minutes) + slack
    elapsed_minutes: number;  // measured; always logged as elapsed-vs-cap
    hit_cap: boolean;         // true ⇒ zombie-runner procedure ran; never a silent continue
  };
  ci_fix_rounds?: number;     // handleCiFailure rounds consumed (bound: 3)
  merged_at?: string;
  // Post-merge sync state (Step 9). On a merged PR, success MUST NOT be true
  // until post_merge_sync.verified === true.
  post_merge_sync?: {
    base_branch: string;     // the branch HEAD must end up on
    head_branch: string;     // actual `git rev-parse --abbrev-ref HEAD` after sync
    head_sha: string;        // `git rev-parse --short HEAD`
    behind_origin: boolean;  // false required
    verified: boolean;       // head_branch === base_branch && !behind_origin
  };
  error?: string;
}

interface ReviewComment {
  author: string;
  body: string;
  file_path?: string;
  line?: number;
  resolved: boolean;
}

{type}({scope}): {gitmoji} {description}

feat(community): ✨ Implement post list screen
fix(auth): 🐛 Fix login token refresh error
chore(deps): 🔧 Update package versions

## Summary
{Issue content summary - 1~3 lines}

## Changes
- {Change 1}
- {Change 2}
- {Change 3}

## Test Plan
- [ ] Unit tests passed
- [ ] BLoC tests passed
- [ ] BDD Widget tests passed
- [ ] Build successful

## 📄 작업내역
- 경로: `.claude/docs/{scope}/pr-work-{issue_number}.html`
- 링크: https://github.com/{owner}/{repo}/blob/{head_branch}/.claude/docs/{scope}/pr-work-{issue_number}.html
{커밋하지 못했으면 `## 📄 작업내역 (마크다운 폴백)` + 요약으로 바꾼다 — skills/pr-work-artifact}

## Screenshots (if applicable)
{Screenshots or N/A}

## Review Wait
{Step 3 outcome — omit this section when `reviewed`; on `none-posted` / `unknown` / `not-configured`
 leave the line here via `gh pr edit --body` (console output is not a durable record)}

---
Closes #{issue_number}

🤖 Generated with [Claude Code](https://claude.ai/claude-code)

┌─────────────────────────────────────────────────────────┐
│  Step 1: Prepare PR Creation                             │
├─────────────────────────────────────────────────────────┤
│  - Verify branch push                                    │
│  - Collect commit list                                   │
│  - Generate PR title/body                                │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 2: Create PR                                       │
├─────────────────────────────────────────────────────────┤
│  - Write work-log HTML, commit it (docs-only commit)     │
│    (non-blocking — markdown fallback if it can't commit) │
│  $ git push -u origin {branch_name}                     │
│  $ gh pr create --draft --title ... --body ... (link)   │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 3: Wait for Review (5 min)                         │
├─────────────────────────────────────────────────────────┤
│  - Pre-check: no AI reviewer -> skip (not-configured)    │
│  - Wait only for AI-author comments (bot allowlist)      │
│  - Check comments every 30 seconds                       │
│  - 5 min cap → outcome reviewed|none-posted|unknown     │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 4: Collect and Analyze Review Comments             │
├─────────────────────────────────────────────────────────┤
│  $ gh pr view {pr_number} --comments                    │
│  - Parse comments                                        │
│  - Extract items requiring fixes                         │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 5: Apply Feedback (if needed)                      │
├─────────────────────────────────────────────────────────┤
│  IF items requiring fixes exist:                         │
│    - Fix code                                            │
│    - Additional commit                                   │
│    $ git commit -m "refactor: ♻️ Apply PR review feedback" │
│    - Per-Push Verification Gate (required before push): │
│      format → dart fix → analyze 0                      │
│      (= /cc-dev:run Step 8.5; fail ⇒ push blocked)         │
│    $ git push                                           │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 6: Check CI Status (hard gate)                     │
├─────────────────────────────────────────────────────────┤
│  $ gh pr ready {pr_number}  (if draft) → wait new run   │
│  $ gh pr checks {pr_number} --watch  (background first)  │
│  - The work-log HTML was committed + linked at Step 2 —  │
│    this step never edits it (PR checks are the record)   │
│  - Join the CI result and gate on it; no comment here    │
│  - Wall-clock cap; on-cap → zombie-runner procedure     │
│  - On failure → handleCiFailure (bound: 3 rounds)       │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 7: Squash Merge (merge = Close)                    │
├─────────────────────────────────────────────────────────┤
│  $ gh pr merge {pr_number} --squash --delete-branch     │
│  - PR merge complete                                     │
│  - Delete source branch                                  │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 8: Verify Issue Closed (GitHub + ZenHub) ⭐        │
├─────────────────────────────────────────────────────────┤
│  ⛔ 0. gh api graphql subIssues (열린 자식? — GD-04)       │
│    → 열림: close 금지 (이미 닫혔으면 gh issue reopen 복구)  │
│    → 조회 실패: 판정 불가 → 명시적 close 보류              │
│  $ gh issue view {issue} --json state -q .state         │
│    → if not CLOSED: gh issue close {issue} --reason completed │
│  searchClosedIssues "#{issue}"                          │
│    → if missing: updateIssue state:CLOSED               │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 9: Post-Merge Sync (base + submodules) ⭐          │
├─────────────────────────────────────────────────────────┤
│  $ git checkout {base_branch}                           │
│  $ git pull --ff-only origin {base_branch}              │
│  $ git submodule sync --recursive                       │
│  $ git submodule update --init --recursive              │
└─────────────────────────────────────────────────────────┘

# Write the work-log HTML and commit it — a docs-only commit, so the Per-Push Gate does not re-run for it
git add .claude/docs/community/pr-work-25.html
git commit -m "docs(community): 📝 작업내역 (#25)"

# Push branch (code commits + the doc commit)
git push -u origin feature/25-community-list

# Create PR — path + link already in the body, not a follow-up comment
# 초안으로 연다 — 2층 CI 저장소에서 초안은 가벼운 층만 돈다. 무거운 층은 Step 6 이 ready 로 올려 한 번 띄운다
# (skills/ci-receipts A-1·A-2). 단층 CI 저장소에서도 해가 없다.
gh pr create --draft \
  --title "feat(community): ✨ Implement post list screen" \
  --body "$(cat <<'EOF'
## Summary
Implement Community post list screen

## Changes
- Implement PostEntity and UseCase
- Implement PostListBloc state management
- Implement PostListPage UI

## Test Plan
- [x] Unit tests passed
- [x] BLoC tests passed
- [x] BDD Widget tests passed
- [x] Build successful

## 📄 작업내역
- 경로: `.claude/docs/community/pr-work-25.html`
- 링크: https://github.com/{owner}/{repo}/blob/feature/25-community-list/.claude/docs/community/pr-work-25.html

↳ review guide · design rationale · local verification results · out of scope

> GitHub 은 HTML 을 소스로 보여 준다 — 렌더된 화면은 체크아웃에서 `open .claude/docs/community/pr-work-25.html` 로 연다.

---
Closes #25

🤖 Generated with [Claude Code](https://claude.ai/claude-code)
EOF
)" \
  --base development

# AI 리뷰어 base login — allowlist SoT: commands/pr/review-processor.md "Reviewer Identification"
#   gemini-code-assist[bot] · claude[bot] · github-copilot[bot]
#   ⚠️ gh 가 `[bot]` 접미사를 붙여 줄 때와 빼고 줄 때가 있으므로 양쪽을 정규화해 비교한다

# 3-0. 사전 판정 — A(PR 트리거 AI 리뷰 워크플로) · B(최근 머지 PR 5건의 AI 리뷰 흔적)
PRECHECK=unknown        # none | present | unknown — none 일 때만 대기를 생략한다
BASE_REF=$(gh pr view "$PR_NUMBER" --json baseRefName -q .baseRefName 2>/dev/null) || BASE_REF=''
if [ -n "$BASE_REF" ] && git fetch origin "$BASE_REF" --quiet 2>/dev/null; then
  A=0
  for f in $(git ls-tree --name-only "origin/$BASE_REF" .github/workflows/ 2>/dev/null); do
    BODY=$(git show "origin/$BASE_REF:$f" 2>/dev/null) || continue
    printf '%s' "$BODY" | grep -q 'anthropics/claude-code-action' || continue
    # 블록형 `pull_request:` 와 한 줄형 `on: [push, pull_request]` 를 센다.
    # `pull_request_review_comment:` 같은 멘션 트리거는 뒤에 `_` 가 붙어 걸리지 않는다
    printf '%s' "$BODY" | grep -qE '^[[:space:]]*pull_request(_target)?:|^on:.*pull_request(_target)?([^_a-z]|$)' \
      && A=$((A + 1))
  done
  if RECENT=$(gh pr list --state merged --limit 5 --json comments,reviews 2>/dev/null); then
    B=$(printf '%s' "$RECENT" | jq '
      ["gemini-code-assist", "claude", "github-copilot"] as $bots
      | [ .[] | (.comments[]?, .reviews[]?)
          | ((.author.login // "") | sub("\\[bot\\]$"; ""))
          | select(. as $a | $bots | index($a)) ] | length')
    # B 가 숫자가 아니면(jq 실패) 비교가 거짓이 되어 present 로 떨어진다 — 생략하지 않는 쪽이다
    if [ "$A" -eq 0 ] && [ "$B" -eq 0 ]; then PRECHECK=none; else PRECHECK=present; fi
  fi
fi
echo "#3: precheck=$PRECHECK workflows=${A:-?} recentAi=${B:-?}"

REVIEW_WAIT=unknown     # reviewed | none-posted | unknown | not-configured — 기본값은 통과가 아니다
FAILS=0

if [ "$PRECHECK" = none ]; then
  REVIEW_WAIT=not-configured              # 폴링 0회 — 이 사실을 PR body 에 남긴다(아래)
else
  for i in {1..10}; do    # 10 tick × 30s = 5 min (budget)
    sleep 30
    RAW=$(gh pr view "$PR_NUMBER" --json comments,reviews 2>/dev/null) || RAW=''
    if [ -z "$RAW" ]; then
      FAILS=$((FAILS + 1))
      echo "#3: tick=$i/10 lookup-failed($FAILS/3)"
      [ "$FAILS" -ge 3 ] && { REVIEW_WAIT=unknown; break; }   # 조회 실패는 '리뷰 없음'이 아니다
      continue
    fi
    FAILS=0
    AI_COUNT=$(printf '%s' "$RAW" | jq '
      ["gemini-code-assist", "claude", "github-copilot"] as $bots
      | [ (.comments[]?, .reviews[]?)
          | ((.author.login // "") | sub("\\[bot\\]$"; ""))
          | select(. as $a | $bots | index($a)) ] | length')
    echo "#3: tick=$i/10 ai=$AI_COUNT"      # 0 은 **주장된 0** 이다 (없음 ≠ 확인함)
    if [ "$AI_COUNT" -gt 0 ]; then REVIEW_WAIT=reviewed; break; fi
    REVIEW_WAIT=none-posted                 # 예산을 다 쓰면 이 값으로 확정된다
  done
fi
echo "#3: outcome=$REVIEW_WAIT"

## Review Wait
- ⚠️ AI review: none-posted (5m/5m, 0 comments from gemini|claude|copilot)
  → 리뷰가 도달하지 않은 것이며, 지적이 없다는 뜻이 아니다.
- ℹ️ AI review: not-configured (PR 트리거 AI 리뷰 워크플로 0 · 최근 머지 PR 5건의 AI 코멘트 0) — 대기 생략
  → 이 저장소엔 AI 리뷰어가 없다. 지적이 없다는 뜻이 아니다.

inv:      PR 은 open · 폴링은 읽기 전용(코멘트/라벨/브랜치에 쓰지 않는다)
          head SHA 가 바뀌면(재푸시) 이 루프는 끝난 것이고 새 SHA 에서 처음부터 다시 시작한다
prog:     tick 단조 증가(30s 단위) + aiComments 는 0 → ≥1 로만 바뀐다
          no-prog: 같은 tick 에서 재조회 금지 — 조회 실패는 FAILS 로 세고 다음 tick 에서만 재시도
term:     precheck == none (not-configured — 폴링 0회) | aiComments >= 1 (reviewed) |
          tick == 10 (none-posted) | FAILS == 3 (unknown)
budget:   사전 판정 1회(PR 조회 2번 + base 워크플로 읽기) + 10 iterations × 30s = 5 min wall-clock.
          조회 실패 재시도에 별도 예산 없음(같은 10 tick 안)
exhaust:  outcome 을 none-posted | unknown 으로 **확정**하고 로그 + PR body 기록 후 Step 4 로 넘긴다.
          무음 통과 금지 · aiComments == 0 을 "지적 0건" 으로 환산 금지 · 그대로 머지 승인 금지
resume:   `gh pr view $PR_NUMBER --json comments,reviews` 재조회로 위치 판정
          (tick 카운터는 /clear 를 못 넘으므로 예산이 아니다) · 폴링은 부작용이 없어 멱등
log:      사전 판정 한 줄 "#3: precheck=present workflows=1 recentAi=0" + tick 당 한 줄 "#3: tick=4/10 ai=0"
          + 종료 시 "#3: outcome=none-posted" 1줄

# Query comments
gh pr view $PR_NUMBER --comments --json comments

# Query review comments
gh api repos/{owner}/{repo}/pulls/$PR_NUMBER/comments

# ⚠️ 수집물에는 리뷰가 아닌 코멘트(사람 메모·파이프라인 경고·예전 방식의 작업내역 마커 코멘트)가 섞여 있다.
#    분석 대상은 Step 3 과 **같은 작성자 allowlist** 로 좁힌다 (allowlist SoT:
#    commands/pr/review-processor.md "Reviewer Identification"). review_wait != 'reviewed' 이면
#    "지적 0건" 이 아니라 **리뷰가 없었음** 이므로, 그 상태로 무음 통과시키지 않는다.

# 0-a) 초안이면 준비 완료로 올린다 — 초안의 초록은 무거운 잡이 skipped 된 결과라 통과가 아니다(skills/ci-receipts).
#      ready 직후 곧바로 watch 하면 ready 전에 끝난 초안 run 의 체크만 보고 끝날 수 있다 —
#      ready 전 run id 와 비교해 새 run 이 보일 때까지(15초 × 12) 기다린다. 없으면 판정 불가로 차단한다(시간 경과로 단층 CI 라고 추정하지 않는다).
#      조회 실패를 "초안 아님"으로 접지 않는다 — 판정 불가는 통과가 아니다.
DRAFT=$(gh pr view "$PR_NUMBER" --json isDraft -q .isDraft) || { echo "#6: 초안 여부 조회 실패 — 판정 불가"; exit 1; }
if [ "$DRAFT" = "true" ]; then
  HEAD_SHA=$(gh pr view "$PR_NUMBER" --json headRefOid -q .headRefOid) || exit 1
  run_ids() {
    local ids
    ids=$(gh run list --commit "$HEAD_SHA" --event pull_request --limit 100 --json databaseId -q '.[].databaseId') || return 1
    printf '%s\n' "$ids" | sort
  }
  BEFORE=$(run_ids) || exit 1
  gh pr ready "$PR_NUMBER" || exit 1
  NEW=""
  for _ in $(seq 12); do
    sleep 15
    AFTER=$(run_ids) || exit 1
    NEW=$(comm -13 <(echo "$BEFORE") <(echo "$AFTER"))
    [ -n "$NEW" ] && break
  done
  if [ -z "$NEW" ]; then
    echo "#6: 새 CI run 확인 불가 — 트리거·대기열 확인 필요. 기존 초안 체크로 머지하지 않는다"
    exit 1
  fi
  echo "#6: draft→ready · 새 run $NEW"
elif [ "$DRAFT" != "false" ]; then
  echo "#6: 초안 여부 판정 불가"
  exit 1
fi

# 0) 기다리기 전에 상한(cap)을 정한다 — 무한 --watch 금지
#    cap = max(이 PR 이 트리거하는 워크플로들의 **job-level** timeout-minutes) + slack 10m
#    숫자 산정 SoT: ../../skills/job-timeout-budget/SKILL.md ③ (T-2/T-3) — 여기서 재정의하지 않는다
CAP_BASE=$(grep -rhoE '^[[:space:]]{2,6}timeout-minutes:[[:space:]]*[0-9]+' .github/workflows/*.y*ml \
  | grep -oE '[0-9]+' | sort -n | tail -1)
#    job-level 과 step-level 구분이 애매하면 **큰 값**을 쓴다(cap 은 상한이므로 과대추정이 안전측).
#    표본이 없으면 형제 정합 선례값 150m (job-timeout-budget ④) — 추측한 숫자를 박지 않는다.
CAP=$(( ${CAP_BASE:-150} + 10 ))
START=$(date +%s)

# 1) Background first — do NOT block here (order is fixed)
gh pr checks $PR_NUMBER --watch --fail-fast    # run_in_background: true

# 2) The work-log HTML is not touched here — PR checks are the record of CI

# 3) Join the CI result **within the cap**.
#    ⚠️ `--watch` 자체는 상한이 없다 → join 은 백그라운드 핸들을 30s 간격으로
#    확인하며 ELAPSED 를 재계산하고, CAP 을 넘으면 기다림을 끊고 4) 로 간다(무한 join 금지).
gh pr checks $PR_NUMBER                        # snapshot after the watch returns (or on cap)
ELAPSED=$(( ( $(date +%s) - START ) / 60 ))
echo "#6: elapsed=${ELAPSED}m/cap=${CAP}m verdict=${CI_VERDICT:-pending}"   # 항상 elapsed-vs-cap 로 남긴다

# 4) on-cap (ELAPSED >= CAP) — 무음 continue 금지, pass 승격 금지.
#    좀비 러너 절차: ../../skills/job-timeout-budget/SKILL.md ⑥ (여기서 절차를 복제하지 않는다)
if [ "$ELAPSED" -ge "$CAP" ] && [ "${CI_VERDICT:-pending}" = "pending" ]; then
  gh api orgs/{owner}/actions/runners --jq '.runners[] | select(.busy==true) | {name,status,busy}'
  #  status=offline && busy=true  → 좀비 확정 → force-cancel 을 **제안**(대화형 세션에서만 ASK):
  #    gh api -X POST repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel
  #  좀비 아님 / 디스패치된 워커(물어볼 사람이 없다, orchestration-graph.md §2)
  #    → blockIssue(issue, 'ci_wait_cap') (holding + 사유 코멘트 + 점유 해제), ci_status 는 'blocked' 로 반환하고 머지하지 않는다
fi

inv:      watch 전에 PR 이 초안이 아니다(0-a) — 초안이면 ready 후 ready 뒤 새 run 을 대상으로 기다린다
          대기 중에는 push 하지 않는다(새 push 는 이 대기를 종료시키고 새 run 을 대상으로 재진입)
          대기 중에는 작업내역 문서를 고치지 않는다 — CI 판정은 PR 체크만 본다(하드 게이트)
prog:     elapsed(min) 단조 증가 + pendingChecks 집합은 단조 비증가
          no-prog: elapsed 가 cap 의 절반을 넘었는데 pendingChecks 가 그대로면 좀비 의심 →
                   ⑥ 의 러너 상태 조회를 1회 선행하고 결과를 로그에 남긴다
term:     모든 체크가 확정(pass|fail) | elapsed >= cap
budget:   cap = max(job-level timeout-minutes) + 10 min slack. 표본 조회 불가 시 160 min
          (= 선례 최대 job-level 150m + slack 10m). 숫자 근거는 job-timeout-budget SKILL 이 SoT
exhaust:  on-cap 은 좀비 러너 절차 → force-cancel 제안(대화형) 또는 blockIssue(issue, 'ci_wait_cap').
          무음 continue 금지 · pass 금지 · 미확정을 'passed' 로 반환 금지
resume:   `gh pr checks $PR_NUMBER` 1회 스냅샷으로 위치 판정(백그라운드 watch 핸들은 세션을 못 넘는다)
          재조회는 읽기 전용이라 멱등 · 재푸시 후에는 새 run 을 대상으로 cap 을 다시 계산한다
log:      join 시 한 줄 "#6: elapsed=12m/cap=160m verdict=pass" + on-cap 시 러너 조회 결과

# Squash merge + delete branch
gh pr merge $PR_NUMBER --squash --delete-branch

# Merge commit message (uses PR title)
# "feat(community): ✨ Implement post list screen (#25)"

# 0. ⛔ 열린 자식 확인 — 열려 있으면 close 하지 않고, 이미 닫혔다면 재오픈해 복구한다.
#    openChildrenStatus(): rules/zenhub-conventions.md → "Child Enumeration Contract"
#    ("open"=열린 자식 있음 · "none"=통과 · "unknown"=조회 실패 → 통과 아님)
OWNER=$(gh repo view --json owner -q .owner.login); NAME=$(gh repo view --json name -q .name)
# GD-04: GitHub 네이티브 subIssues (recency 창 없음). state 는 대문자(OPEN/CLOSED).
# ⚠️ 실패 시 gh 는 에러 JSON 을 **stdout** 으로 쏟는다 → 마커는 부분일치로 판정한다
#    (`[ "$X" = "__LOOKUP_FAILED__" ]` 완전일치는 에러 JSON 이 앞에 붙어 매칭에 실패한다)
OPEN_KIDS=$(gh api graphql -f query="{ repository(owner:\"$OWNER\", name:\"$NAME\") \
  { issue(number:$ISSUE_NUMBER) { subIssues(first:100) { nodes { number state } } } } }" \
  -q '[.data.repository.issue.subIssues.nodes[] | select(.state=="OPEN") | .number] | join(",")' \
  2>/dev/null || echo "__LOOKUP_FAILED__")
ISSUE_TYPE="${ISSUE_TYPE:-}"   # ZenHub issueType (Sub-task 는 구조적 leaf → unknown 시 통과 허용)

if [[ "$OPEN_KIDS" == *__LOOKUP_FAILED__* && "$ISSUE_TYPE" != "Sub-task" ]]; then
  # unknown — 컨테이너일 수 있으므로 차단 (mayClose(): rules/zenhub-conventions.md)
  echo "⚠️ #$ISSUE_NUMBER 자식 조회 실패 — 열린 자식 여부 미확인, 명시적 close 보류"
  echo "   → gh auth status 확인 후 재실행하거나, 하위 이슈를 수동 확인하십시오"
  exit 1
elif [[ "$OPEN_KIDS" != *__LOOKUP_FAILED__* && -n "$OPEN_KIDS" ]]; then
  echo "⛔ #$ISSUE_NUMBER 열린 자식 있음($OPEN_KIDS) — close 하지 않는다"
  # `Closes #N` 이 이미 닫아 버린 경우: 재오픈 → (reopen 이후에만) In Progress 로 복구
  [ "$(gh issue view $ISSUE_NUMBER --json state -q .state)" = "CLOSED" ] && {
    gh issue reopen $ISSUE_NUMBER
    gh issue comment $ISSUE_NUMBER --body "⚠️ 열린 하위 이슈가 남아 재오픈했습니다: $OPEN_KIDS"
    # + reopen 이후 In Progress 로 이동 (moveIssueToPipeline — 아래 typescript 블록 참조)
  }
  exit 1   # ⛔ Step 8 종료 — 아래 1·2(명시적 close)는 실행하지 않는다
fi
# ↑ 여기까지 왔으면 status = none (또는 Sub-task 의 unknown 경고 통과) → 정상 close 경로

# `Closes #N` fires only on default-branch merges; hierarchical (non-default base) merges never auto-close.
DEFAULT_BRANCH=$(gh repo view --json defaultBranchRef -q .defaultBranchRef.name)

# 1. GitHub is the source of truth for open/closed — close explicitly whenever still open
STATE=$(gh issue view $ISSUE_NUMBER --json state -q .state)
if [ "$STATE" != "CLOSED" ]; then
  # base != default (hierarchical merge), missing keyword, cross-repo link, etc.
  gh issue close $ISSUE_NUMBER --reason completed
fi

// 2. Confirm ZenHub synced GitHub closed → Closed pipeline (fallback on sync lag)
const closed = await mcp__zenhub__searchClosedIssues({ query: `#${issueNumber}` });
if (!closed.find(i => i.number === issueNumber)) {
  await mcp__zenhub__updateIssue({ issueId, state: "CLOSED" });
}

// 파이프라인 id (fail-closed)
const ws = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const pipe = (name) => {
  const p = ws.pipelines.find(p => p.name === name);
  if (!p) throw new Error(`파이프라인 '${name}' 없음. 라이브: ${ws.pipelines.map(p => p.name).join(", ")}`);
  return p;
};

// A) Abandoned: PR이 머지 없이 닫힘(mergedAt == null) → 이슈를 In Progress 로 되돌리고 surface.
//    verify_closed(Step 8)는 GitHub state 기반이라 OPEN 이슈엔 안 걸린다 — 명시 분기가 필요.
const pr = JSON.parse(await Bash(`gh pr view ${prNumber} --json state,mergedAt`));
if (pr.state === "CLOSED" && !pr.mergedAt) {
  await mcp__zenhub__moveIssueToPipeline({ issueId, pipelineId: pipe("In Progress").id });
  console.warn(`⚠️ PR #${prNumber} 머지 없이 닫힘 — 이슈 #${issueNumber} 를 In Progress 로 되돌림(재작업/대체 필요).`);
  // 작업 자체를 포기하면 사용자 판단으로 Sprint Backlog/Icebox 재분류 또는 명시적 close(gh issue close).
}

// B) Rework: 리뷰가 변경 요청(CHANGES_REQUESTED) 또는 CI 실패 → Review/QA 에서 In Progress 로 되돌림.
if (reviewDecision === "CHANGES_REQUESTED" || ciStatus === "failed") {
  await mcp__zenhub__moveIssueToPipeline({ issueId, pipelineId: pipe("In Progress").id });
  // 재작업 후 re-push 하면 PR 갱신 단계에서 다시 Review/QA 로 이동한다(작업-상태 가시성 유지).
}

# base_branch = PR base (hierarchy: parent branch, independent: development)
git checkout $BASE_BRANCH
git pull --ff-only origin $BASE_BRANCH
git submodule sync --recursive
git submodule update --init --recursive

# Verify before returning — required to set post_merge_sync.verified = true
HEAD_BRANCH=$(git rev-parse --abbrev-ref HEAD)
test "$HEAD_BRANCH" = "$BASE_BRANCH" || echo "❌ not on base branch: $HEAD_BRANCH"
git status -sb | head -1 | grep -q 'behind' && echo "❌ base is behind origin — re-pull"

# 머지 — 지정 PR 까지의 PR 들이 단일 all-or-nothing 연산으로 머지된다
gh stack merge $PR_NUMBER --squash -y

# 머지 후: 다음 미머지 PR 은 서버가 자동으로 rebase + 스택 base 로 retarget 해 맨 아래로 내려온다.
# 로컬 스택은 아래 명령으로 맞춘다 (--prune 이 머지된 PR 의 브랜치를 정리한다)
gh stack sync --prune

1. Analyze failure cause — 실패한 검사 · 테스트를 **로컬에서 재현**한다(좁혀 실행.
   같은 기계에 셀프호스트 러너가 있으면 전체 실행 금지 — 러너를 굶긴다)
   ├─ 재현됨 → 2
   └─ 재현 안 됨 + 플레이크 · 러너 문제로 진단(근거: 같은 잡의 간헐 실패 이력 · 러너 디스크/네트워크 오류 등)
        → gh run rerun <run-id> --failed   (실패 잡만 — 전체 재실행 · 빈 커밋 push 금지) → 6 (이것도 라운드 하나)
   ↓
2. Determine if auto-fix is possible
   ↓
3. Apply fix
   ↓
4. Per-Push Verification Gate (format → analyze 0)
   ↓
5. Commit & push
   ↓
6. Wait for CI re-run       (= Step 6 계약으로 재진입, 그 cap 을 그대로 쓴다)
   ↓
7. Verify success/failure   (실패면 다음 라운드 — 단, 아래 계약대로 **최대 3 라운드**)

inv:      push 되는 커밋은 예외 없이 Step 8.5 per-push gate 를 통과한 것 (analyze 0)
          `// ignore:` 삽입 · `LEFTHOOK=0` · **진단 없는** 재실행으로 초록을 만드는 것 금지 — 플레이크 · infra/runner 로
          진단된 실패만 `gh run rerun <run-id> --failed`(실패 잡만, 라운드로 센다). 전체 재실행 · 빈 커밋 push 금지
          수정 커밋은 그 실패를 로컬에서 재현 · 수정 · 검증한 것이다 — CI 를 시험 루프로 쓰지 않는다
          같은 PR 을 고친다 — 작업내역을 고쳐야 하면 그 수정 커밋에 함께(문서만의 커밋·push 금지, 새 링크·새 코멘트 금지)
prog:     failingChecks 가 **진부분집합으로 축소**되거나, 진단된 원인의 KIND 가 직전 라운드와 다르다
          (kind ∈ {build, test, lint, analyze, infra/runner, flake}) — 둘 다 아니면 진전 0
          no-prog: 같은 실패 집합 + 같은 KIND 로 두 번째 수정 금지 →
                   ../sequential-workflow.md 의 Rung 2(`/cc-dev:unstuck`)로 종류를 바꾼다
term:     failingChecks == ∅ (outcome=fixed) | rounds == 3 (outcome=ci_exhausted)
budget:   3 rounds (라운드 = 수정 1 + push 1 + CI 재대기 1). 라운드마다 Step 6 이 자기 cap 으로
          재진입하며, 중첩 대기는 3 × cap 을 넘지 않는다
exhaust:  라벨 `ci-blocked` + BLOCKED('ci_exhausted') + 제어 반환. **다시 push 하지 않고 머지하지 않는다**
resume:   `gh pr checks` 실측 + PR 라벨(`ci-blocked`) + 라운드 기록 코멘트로 위치 판정
          (대화 카운터는 /clear 를 못 넘으므로 예산이 아니다) · 라운드 기록은 마커 코멘트 1개에 upsert
log:      라운드당 한 줄 "ci-fix #2: failing 3→1 kind=test→analyze"
          + 소진 시 남은 실패 체크 이름 전부와 마지막 진단 KIND

gh pr edit "$PR_NUMBER" --add-label ci-blocked
gh pr comment "$PR_NUMBER" --body "⛔ CI 수정 3라운드 소진 — 남은 실패: $FAILING. 사람 개입 필요."
# + 보드 반영: blockIssue(issue, 'ci_exhausted') — [Pipeline State Contract](../../rules/zenhub-conventions.md#pipeline-state-contract)
#   (holding 이동 + createBlockage(차단자가 이슈일 때만) + 사유 코멘트 + 점유 해제를 한 묶음으로)
#   (createBlockage + holding 컬럼 이동) · 이슈는 Review/QA → In Progress (Step 8.5 B)
# ⛔ 여기서 제어를 반환한다. 재푸시 금지 · 머지 금지 · ci_status = 'blocked' 로 보고한다.

# Resolve conflicts
git fetch origin development
git rebase origin/development
# Manually resolve conflicts
git add .
git rebase --continue
# Per-Push Verification Gate — rebase 결과물도 예외 없이 push 전 재검증
dart format . && dart fix --apply
melos run analyze        # 0건 필수 (실패 시 push 금지)
git push --force-with-lease

# 1. Update development branch
git checkout development
git pull origin development

# 2. Code generation on Backend changes [required]
melos run backend:pod:generate

# 3. Commit generated code (if changes exist)
git add .
git commit -m "chore(backend): 🔧 code generation"
git push origin development

# After merging development in a feature branch
git merge development

# If there were Backend changes, run code generation
melos run backend:pod:generate