interface PRResult {
  success: boolean;
  pr_number: number;
  pr_url: string;
  pr_status:  ' open '   |  ' merged '   |  ' closed ' ;
  review_comments: ReviewComment[];
  // Step 3 outcome (tri-state). Only  ' reviewed '   may proceed silently; the other two MUST be
  // logged AND recorded in the PR body.  ' unknown '   is never a pass (undet:fail).
  review_wait:  ' reviewed '   |  ' none-posted '   |  ' unknown ' ;
  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

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

## Review Wait
{Step 3 outcome — omit this section when `reviewed`; on `none-posted` / `unknown` leave the
 warning 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                                       │
├─────────────────────────────────────────────────────────┤
│  $ git push -u origin {branch_name}                     │
│  - Publish work-log artifact first, get URL              │
│    (non-blocking — markdown fallback if unavailable)      │
│  $ gh pr create --title  " ... "   --body  " ... "   (link in body) │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 3: Wait for Review (5 min)                         │
├─────────────────────────────────────────────────────────┤
│  - 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 → dcm error 0        │
│      (= /cc-dev:run Step 8.5; fail ⇒ push blocked)         │
│    $ git push                                           │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 6: Check CI Status ∥ refresh work-log artifact     │
├─────────────────────────────────────────────────────────┤
│  $ gh pr checks {pr_number} --watch  (background first)  │
│  - The artifact was already published + linked in the   │
│    PR body at Step 2 — no comment is created here        │
│  - Join the CI result, then republish to the SAME URL   │
│    so the page ' s CI section reflects the final verdict   │
│  - 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              │
└─────────────────────────────────────────────────────────┘

# Push branch
git push -u origin feature/25-community-list

# Publish work-log artifact first, capture the URL (or fall back to inline markdown)

# Create PR — link block already in the body, not a follow-up comment
gh pr create \
  --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

## 📄 작업내역
**{artifact_url}**
↳ review guide · design rationale · test/verification results · out of scope
(share notice per `artifact-publishing.md` §2)

---
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]` 접미사를 붙여 줄 때와 빼고 줄 때가 있으므로 양쪽을 정규화해 비교한다
REVIEW_WAIT=unknown     # reviewed | none-posted | unknown — 기본값은 통과가 아니다
FAILS=0

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
echo  " #3: outcome=$REVIEW_WAIT "

## Review Wait
- ⚠️ AI review: none-posted (5m/5m, 0 comments from gemini|claude|copilot)
  → 리뷰가 도달하지 않은 것이며, 지적이 없다는 뜻이 아니다.

inv:      PR 은 open · 폴링은 읽기 전용(코멘트/라벨/브랜치에 쓰지 않는다)
          head SHA 가 바뀌면(재푸시) 이 루프는 끝난 것이고 새 SHA 에서 처음부터 다시 시작한다
prog:     tick 단조 증가(30s 단위) + aiComments 는 0 → ≥1 로만 바뀐다
          no-prog: 같은 tick 에서 재조회 금지 — 조회 실패는 FAILS 로 세고 다음 tick 에서만 재시도
term:     aiComments  > = 1 (reviewed) | tick == 10 (none-posted) | FAILS == 3 (unknown)
budget:   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:      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

# ⚠️ 수집물에는 파이프라인 자기 코멘트( < !-- cc-dev:pr-work-artifact -- >   마커)가 섞여 있다.
#    분석 대상은 Step 3 과 **같은 작성자 allowlist** 로 좁힌다 (allowlist SoT:
#    commands/pr/review-processor.md  " Reviewer Identification " ). review_wait !=  ' reviewed '   이면
#     " 지적 0건 "   이 아니라 **리뷰가 없었음** 이므로, 그 상태로 무음 통과시키지 않는다.

# 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) Join the CI result, then republish to the SAME url (Step 2 ' s artifact_url, unchanged)
#    Protocol:  plugins/cc-dev/skills/pr-work-artifact/SKILL.md
#    Mechanics: plugins/cc-dev/rules/artifact-publishing.md   (do not duplicate either here)

# 3) Join the CI result **within the cap**, then republish to the SAME url so the page stops
#    saying  " running " . ⚠️ `--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:      대기 중에는 push 하지 않는다(새 push 는 이 대기를 종료시키고 새 run 을 대상으로 재진입)
          아티팩트 발행 성공/실패는 CI 판정에 영향을 주지 않는다(발행은 비차단, 판정은 하드 게이트)
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. Determine if auto-fix is possible
   ↓
3. Apply fix
   ↓
4. Per-Push Verification Gate (format → analyze 0 → dcm error 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 · dcm error 0)
          `// ignore:` 삽입 · `LEFTHOOK=0` · 재실행만으로 초록을 만드는 것 금지
          같은 PR·같은 아티팩트 URL·같은 마커 코멘트를 갱신한다(새 링크/새 코멘트 금지)
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 전 재검증
melos run format  & &   dart fix --apply
melos run analyze        # 0건 필수 (실패 시 push 금지)
melos run dcm:analyze    # error 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