/cc-dev:zenhub:manage {action} [--options]

const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
// workspace.pipelines → [{ id, name }, ...]
// Live pipelines (6): New Issues, Icebox, Product Backlog, Sprint Backlog, In Progress, Review/QA
// (no  " Done " / " Closed "   column — close via gh issue close + updateIssue state:CLOSED)

# Move issue to In Progress
/cc-dev:zenhub:manage move --issue {issue_number} --to  " In Progress "

# Include  " Closes #{issue_number} "   in PR body (GitHub auto-link)
# Move issue to Review/QA
/cc-dev:zenhub:manage move --issue {issue_number} --to  " Review/QA "

# Issue auto-closes via  " Closes # "   keyword in PR body → ZenHub syncs to Closed.
# Never move to Done (Done ≠ closed). Verify + fallback:
#   gh issue view {n} --json state  → if not CLOSED: gh issue close {n} --reason completed
#   searchClosedIssues  " #{n} "         → if missing:    updateIssue state:CLOSED

/cc-dev:zenhub:manage sync-closed                  # scan issues closed on GitHub in the last 7 days (default)
/cc-dev:zenhub:manage sync-closed --since 30d      # widen the lookback window
/cc-dev:zenhub:manage sync-closed --issue 1413     # check/fix exactly one issue
/cc-dev:zenhub:manage sync-closed --repo owner/name  # target a repo other than the current cwd ' s

// 1. Resolve the scan set
const repo = args.repo ?? (await Bash(`gh repo view --json nameWithOwner -q .nameWithOwner`)).trim();
let candidates;
if (args.issue) {
  candidates = [{ number: Number(args.issue) }];
} else {
  const since = parseSinceToISODate(args.since ??  " 7d " ); // e.g.  " 7d "   → 7 days ago, ISO date
  const raw = await Bash(
    `gh issue list --repo ${repo} --state closed --search  " closed: > =${since} "   --json number,title,closedAt --limit 200`
  );
  candidates = JSON.parse(raw);
  // No silent cap: if exactly 200 came back, the window likely truncated — warn and suggest a narrower --since.
  if (candidates.length === 200) log(`⚠️ 200개 상한 도달 — --since를 좁혀 재실행 권장`);
}

// 2. Reconcile each against ZenHub
const results = { synced: [], alreadyOk: [], notFoundInZenhub: [] };
for (const { number: n } of candidates) {
  const closedInZenhub = await mcp__zenhub__searchClosedIssues({ query: `#${n}` });
  if (closedInZenhub.find(i = >   i.number === n)) {
    results.alreadyOk.push(n);
    continue;
  }
  const latest = await mcp__zenhub__searchLatestIssues({ query: `#${n}` });
  const match = latest.find(i = >   i.number === n);
  if (!match) {
    results.notFoundInZenhub.push(n); // not tracked by ZenHub at all — nothing to sync
    continue;
  }
  await mcp__zenhub__updateIssue({ issueId: match.id, state:  " CLOSED "   });
  results.synced.push(n);
}

// 3. ⛔ Parent Closure Invariant 점검 —  " 닫힌 부모 + 열린 자식 "   조합을 찾아 복구한다.
//    rules/zenhub-conventions.md →  " Parent Closure Invariant "   /  " Child Enumeration Contract " 
 //    ZenHub 동기화(2번)는  " 닫힌 게 맞다 " 를 전제로 하지만, 애초에 닫히면 안 되는 이슈도 있다.
results.reopened = [];
results.childLookupFailed = [];
// fail-closed 파이프라인 ID 해석 — 못 찾으면 throw (undefined 를 move 에 넘겨 무음 누락 금지)
const _ws = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const _inProgress = _ws.pipelines.find(p = >   p.name ===  " In Progress " );
if (!_inProgress) throw new Error(` ' In Progress '   파이프라인 없음. 라이브: ${_ws.pipelines.map(p = >   p.name).join( " ,  " )}`);
const inProgressPipelineId = _inProgress.id;
for (const { number: n } of candidates) {
  const kids = await openChildrenStatus(n);          // GitHub sub-issues, tri-state
  if (kids.status ===  " unknown " ) { results.childLookupFailed.push(n); continue; }
  if (kids.status !==  " open " ) continue;              // 자식 없음/전부 닫힘 → 정상
  const list = kids.open.map(c = >   " # "   + c.number).join( " ,  " );
  await Bash(`gh issue reopen ${n}`);
  await Bash(`gh issue comment ${n} --body  " ⚠️ 열린 하위 이슈가 남아 있어 재오픈했습니다: ${list} " `);
  // reopen 이후에만 파이프라인 이동 (닫힌 이슈를 열린 칸으로 옮기면 GitHub 이 재오픈시킨다)
  const zh = (await mcp__zenhub__searchLatestIssues({ query: `#${n}` })).find(i = >   i.number === n);
  if (zh) await mcp__zenhub__moveIssueToPipeline({ issueId: zh.id, pipelineId: inProgressPipelineId });
  results.reopened.push({ number: n, open: kids.open.map(c = >   c.number) });
}

// 4. Report — never leave a silent partial result
log(`동기화 완료: ${results.synced.length}건 / 이미 일치: ${results.alreadyOk.length}건 / ZenHub 미추적: ${results.notFoundInZenhub.length}건`);
if (results.reopened.length) {
  log(`⛔ 열린 자식이 남아 재오픈: ${results.reopened.map(r = >   `#${r.number}(자식 ${r.open.length})`).join( " ,  " )}`);
  log(`   → 각 부모는 남은 자식 처리 후 /cc-dev:batch {번호} 로 마무리하십시오`);
}
if (results.childLookupFailed.length) log(`⚠️ 자식 조회 실패(판정 불가): ${results.childLookupFailed.map(n = >   " # "   + n).join( " ,  " )}`);

/cc-dev:zenhub:manage sweep-stale-claims             # In Progress 전수 점검 후 낡은 점유만 회수
/cc-dev:zenhub:manage sweep-stale-claims --dry-run   # 무엇을 되돌릴지만 출력 (변경 없음)
/cc-dev:zenhub:manage sweep-stale-claims --ttl 8h    # TTL 조정 (기본 4h — batch --worker-timeout 과 동일)

// 1. In Progress 칸의 이슈를 전수 조회 (이 명령의 대상은 그 칸 하나뿐이다)
const ws = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const inProgress = ws.pipelines.find(p = >   p.name ===  " In Progress " );
if (!inProgress) throw new Error(` ' In Progress '   파이프라인 없음. 라이브: ${ws.pipelines.map(p= > p.name).join( " ,  " )}`);
// ⚠️ repositoryIds 는 필수다 — 빼면 호출이 실패한다(워크스페이스 전 저장소를 넘긴다)
const issues = await mcp__zenhub__getIssuesInPipeline({
  pipelineId: inProgress.id,
  repositoryIds: ws.githubRepositories.map(r = >   r.id),
});

// 2. 회수 조건은 **둘 다** 성립할 때만 (하나만으로는 살아 있는 작업을 죽인다)
for (const issue of issues) {
  const status = await claimStatus(issue.number, me);      // Work Claim Contract
  if (status ===  " other-live "   || status ===  " mine " ) continue;   // ⛔ 살아 있는 점유는 건드리지 않는다
  if (status ===  " unknown " ) { log(`⚠️ #${issue.number} 판정 불가 — 건너뜀`); continue; }

  // status ===  " stale " (TTL 초과 + 브랜치/PR 활동 없음) 또는  " none " (대장 없음)
  //   -  " none "   은 cascade 로 올라온 컨테이너일 수 있다 → **자식이 열려 있으면 정상**이므로 제외한다
  const kids = await openChildrenStatus(issue.number);
  if (kids.status !==  " none " ) { log(`↩︎ #${issue.number} 컨테이너(진행 중 자식 있음) — 유지`); continue; }
  if (status ===  " none "   & &   await hasRecentActivity(issue.number, null, ttl)) continue;  // 대장 없는 사람 작업

  if (args.dryRun) { log(`(dry-run) #${issue.number} → Sprint Backlog`); continue; }
  await reflectBoardState(issue,  " aborted " );              // holding 으로 회수
  await releaseClaim(issue,  " swept:stale-claim " );          // 대장을 released 로 (지우지 않는다)
  await Bash(`gh issue comment ${issue.number} --body  " 🧹 낡은 점유 회수 — 마지막 활동 이후 ${ttlLabel} 경과. 이어서 하려면 \`/cc-dev:run ${issue.number}\` " `);
}

## Related Issue
- Closes #1413
- Fixes #1413
- Resolves #1413

mcp__zenhub__searchLatestIssues({ query:  " 1413 "   })

// Query workspace info (on first call)
const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const reviewPipeline = workspace.pipelines.find(p = >   p.name ===  " Review/QA " );
// fail-closed: 못 찾으면 throw (이름 불일치 시 undefined.id 무음 누락 방지)
if (!reviewPipeline) throw new Error(` ' Review/QA '   파이프라인 없음. 라이브: ${workspace.pipelines.map(p = >   p.name).join( " ,  " )}`);

mcp__zenhub__moveIssueToPipeline({
  issueId:  " {issue_graphql_id} " ,
  pipelineId: reviewPipeline.id
})

// Repository ID + Pipeline ID
const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();

// Issue Type ID
const issueTypes = await mcp__zenhub__getIssueTypes();