interface PRResult {
  success: boolean;
  pr_number: number;
  pr_url: string;
  pr_status:  ' open '   |  ' merged '   |  ' closed ' ;
  review_comments: ReviewComment[];
  ci_status:  ' passed '   |  ' failed '   |  ' pending ' ;
  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}

---
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}                     │
│  $ gh pr create --title  " ... "   --body  " ... "                │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 3: Wait for Review (5 min)                         │
├─────────────────────────────────────────────────────────┤
│  - Wait for Gemini, Claude auto-review comments          │
│  - Check comments every 30 seconds                       │
│  - Wait up to 5 minutes                                  │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  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        │
│      (= /dev:run Step 8.5; fail ⇒ push blocked)         │
│    $ git push                                           │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  Step 6: Check CI Status                                 │
├─────────────────────────────────────────────────────────┤
│  $ gh pr checks {pr_number}                             │
│  - Wait for all checks to pass                           │
│  - On failure → attempt fix or report                    │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│  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) ⭐        │
├─────────────────────────────────────────────────────────┤
│  $ 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

# Create PR
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

---
Closes #25

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

# Check every 30 seconds for 5 minutes
for i in {1..10}; do
  sleep 30
  COMMENTS=$(gh pr view $PR_NUMBER --comments --json comments -q  ' .comments | length ' )
  if [  " $COMMENTS "   -gt 0 ]; then
    break
  fi
done

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

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

# Check CI check status
gh pr checks $PR_NUMBER

# Wait for checks to pass (up to 10 min)
gh pr checks $PR_NUMBER --watch --fail-fast

# 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) "

# `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 "

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
   ↓
7. Verify success/failure

# 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