/cc-dev:zenhub:team-align [--sprint current|next| < name > ] [--rebalance] [--dry-run]

// Sprint Selector Resolution — see rules/zenhub-conventions.md (do not redefine).
//   current → getSprint() (active) | next → getUpcomingSprint() | num/name → listRecentSprints().openSprints
const sprint = await resolveSprint(opts.sprint ||  " current " ); // current = ACTIVE (getSprint), NOT getUpcomingSprint
if (!sprint) throw new Error(`스프린트 해석 실패:  ' ${opts.sprint} ' . listRecentSprints().openSprints 에서 매칭 없음`);

const roster = await mcp__zenhub__getTeamMembers(); // [{ id, login/name, ... }]

// Prefer the sprint ' s own issue set; fall back to scanning active-work pipelines.
let issues = sprint.issues || [];
if (!issues.length) {
  const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
  const repositoryIds = workspace.githubRepositories.map(r = >   r.id); // getIssuesInPipeline REQUIRES repositoryIds
  // Live pipelines (6): New Issues, Icebox, Product Backlog, Sprint Backlog, In Progress, Review/QA — no Done/Closed.
  const scanNames = [ " Sprint Backlog " ,  " In Progress " ,  " Review/QA " ];
  for (const name of scanNames) {
    const p = workspace.pipelines.find(p = >   p.name === name);
    if (!p) throw new Error(` ' ${name} '   파이프라인 없음. 라이브: ${workspace.pipelines.map(p = >   p.name).join( " ,  " )}`);
    const inPipe = await mcp__zenhub__getIssuesInPipeline({ pipelineId: p.id, repositoryIds });
    issues.push(...(inPipe.issues || inPipe).filter(i = >   i.sprintId === sprint.id || (i.sprints || []).some(s = >   s.id === sprint.id)));
  }
}

// Normalize each issue → { number, id, assignee, priority, estimate, epic }
//   priority: p-label (p0/p1/p2)  ·  effort: estimate (setIssueEstimate)  — see  " Matrix Signals "   in conventions
const rows = issues.map(i = >   ({
  number: i.number,
  id: i.id,
  assignee: (i.assignees  & &   i.assignees[0]  & &   (i.assignees[0].login || i.assignees[0].name)) || null,
  priority: (i.labels || []).map(l = >   l.name).find(l = >   /^p[012]$/.test(l)) || null,
  estimate: (i.estimate  & &   i.estimate.value) || i.estimate || 0,
  epic: (i.parent  & &   i.parent.title) || (i.epic  & &   i.epic.title) || null,
}));

const CAPACITY = 8; // points per person per sprint (tune per team; surfaced in report header)

// (a) OVER-ALLOCATED — points or P0-count beyond one person ' s capacity
const byPerson = {};
for (const r of rows.filter(r = >   r.assignee)) {
  const a = (byPerson[r.assignee] ||= { points: 0, p0: 0, issues: [] });
  a.points += r.estimate; if (r.priority ===  " p0 " ) a.p0++; a.issues.push(r.number);
}
const overAllocated = Object.entries(byPerson)
  .filter(([, a]) = >   a.points  >   CAPACITY || a.p0  > = 2)
  .map(([person, a]) = >   ({ person, ...a }));

// (b) UNASSIGNED-HIGH-PRIORITY — P0/P1 with no assignee
const unassignedHigh = rows.filter(r = >   !r.assignee  & &   (r.priority ===  " p0 "   || r.priority ===  " p1 " ));

// (c) CROSS-EPIC-COLLISION — same assignee holds P0 in ≥2 distinct Epics
const collisions = Object.values(
  rows.filter(r = >   r.assignee  & &   r.priority ===  " p0 "   & &   r.epic)
      .reduce((acc, r) = >   {
        const k = r.assignee; (acc[k] ||= { person: r.assignee, epics: new Set(), issues: [] });
        acc[k].epics.add(r.epic); acc[k].issues.push(r.number); return acc;
      }, {}))
  .filter(c = >   c.epics.size  > = 2)
  .map(c = >   ({ person: c.person, epics: [...c.epics], issues: c.issues }));

🧭 Team Alignment —  < sprint.name >   (capacity ${CAPACITY} pt/person)
── Over-allocated ──────────
   < person > :  < points >   pt,  < p0 >   × P0   (# < issues… > )
── Unassigned high-priority ─
  # < number >   [ < priority > ] —  < title >     (Epic:  < epic > )
── Cross-Epic P0 collisions ─
   < person > : P0 in  < epicA > ,  < epicB >     (# < issues… > )
(no writes performed — read-only)

if (opts.rebalance) {
  // Build a proposal: move surplus issues from over-allocated people → under-loaded roster members.
  const proposal = buildReassignmentProposal({ rows, byPerson, roster, capacity: CAPACITY });
  // proposal: [{ issueNumber, issueId, from, to, reason }]

  if (!proposal.length) { print( " 재배분 제안 없음 (균형 상태) " ); return; }

  if (opts.dryRun) { printProposalTable(proposal); print( " --dry-run: assignIssues 미실행 " ); return; }

  // APPROVAL GATE — never write without explicit user approval
  const decision = await AskUserQuestion({
    questions: [{
      question: `다음 ${proposal.length}건 재배분을 적용할까요?\n` +
        proposal.map(p = >   `#${p.number}: ${p.from ||  " (미할당) " } → ${p.to} — ${p.reason}`).join( " \n " ),
      options: [ " Apply all " ,  " Skip (report only) " ],
    }],
  });
  if (decision !==  " Apply all " ) { print( " 재배분 취소 — 변경 없음 " ); return; }

  for (const p of proposal) {
    await mcp__zenhub__assignIssues({ issueIds: [p.issueId], assigneeIds: [resolveAssigneeId(roster, p.to)] });
  }
}

// Roster
const roster = await mcp__zenhub__getTeamMembers();

// Sprint (current = ACTIVE; next = upcoming — DO NOT confuse them)
const active   = await mcp__zenhub__getSprint();          // active sprint
const upcoming = await mcp__zenhub__getUpcomingSprint();  // NEXT sprint, not active
const { openSprints } = await mcp__zenhub__listRecentSprints(); // [{ id, name }] for name/number match

// Pipeline scan (fallback) — getIssuesInPipeline REQUIRES repositoryIds
const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const repositoryIds = workspace.githubRepositories.map(r = >   r.id);
const sb = workspace.pipelines.find(p = >   p.name ===  " Sprint Backlog " );
if (!sb) throw new Error(` ' Sprint Backlog '   파이프라인 없음. 라이브: ${workspace.pipelines.map(p = >   p.name).join( " ,  " )}`);
await mcp__zenhub__getIssuesInPipeline({ pipelineId: sb.id, repositoryIds });

// Detail fetch — there is NO getIssue / getChildrenOfParent. Use search.
await mcp__zenhub__searchLatestIssues({ query:  " #1413 "   });        // by number
await mcp__zenhub__searchLatestIssues({ query:  " parent: < graphqlId > "   }); // children of an Epic

// The ONLY write in this command (approval-gated)
await mcp__zenhub__assignIssues({ issueIds: [ " < graphqlId > " ], assigneeIds: [ " < memberId > " ] });