/cc-dev:zenhub:rerank [--scope backlog|all] [--dry-run] [--by impact|tier]

const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const repoIds = workspace.githubRepositories.map(r = >   r.id);
if (repoIds.length === 0) throw new Error( " 저장소 0개 — 라이브 워크스페이스 확인 필요 " );

// 3 backlog pipelines, every find() must be fail-closed (never an unguarded .id)
const want = [ " Product Backlog " ,  " Sprint Backlog " ,  " Icebox " ];
const backlogPipelines = want.map(name = >   {
  const p = workspace.pipelines.find(p = >   p.name === name);
  if (!p) throw new Error(`파이프라인  " ${name} "   없음. 라이브: ${workspace.pipelines.map(p = >   p.name).join( " ,  " )}`);
  return p;
});
// NOTE: there is NO  " Done " / " Closed "   column. Reranking never closes issues
// and never moves to a Done column — see  " Issue Closure Policy "   in rules/zenhub-conventions.md.

let issues = [];
for (const p of backlogPipelines) {
  const res = await mcp__zenhub__getIssuesInPipeline({ pipelineId: p.id, repositoryIds: repoIds });
  issues.push(...res.issues.map(i = >   ({ ...i, _pipeline: p.name })));
}
// --scope all: also pull unassigned/loose issues (no getIssue/getChildrenOfParent exist)
if (scope ===  " all " ) {
  const loose = await mcp__zenhub__searchLatestIssues({ query:  " no:pipeline "   });
  issues.push(...loose.issues.map(i = >   ({ ...i, _pipeline: null })));
}

// Per-issue signals from labels/estimate/parent (labels are IMMUTABLE — read only)
const tierRank = {  " p0 " : 0,  " p1 " : 1,  " p2 " : 2 };          // priority label → rank
const impactRank = {  " impact-high " : 0,  " impact-med " : 1,  " impact-low " : 2 };
const sig = issues.map(i = >   {
  const labels = (i.labels || []).map(l = >   l.name);
  return {
    id: i.id, number: i.number, title: i.title, pipeline: i._pipeline,
    level: i.issueType?.level ?? null,                      // hierarchy level (1=Initiative..5=Sub-task) — see Level Separation
    tier: labels.find(n = >   tierRank[n] !== undefined) ??  " p2 " ,
    impact: labels.find(n = >   impactRank[n] !== undefined) ??  " impact-low " ,
    estimate: i.estimate?.value ?? null,                  // effort signal (setIssueEstimate)
    parentId: i.parent?.id ?? null,                        // dependency / Epic grouping
  };
});

// Level Separation (see Options table): split Story-level (L4) from Epic/Project-level (L2-3)
// BEFORE sorting, so the two are never compared on the same priority axis.
const storyLevelSig = sig.filter(s = >   s.level == null || s.level  > = 4);
const upperLevelSig = sig.filter(s = >   s.level != null  & &   s.level  <   4);

const by = opts.by ??  " tier " ;
const cmp = (a, b) = >   {
  const t = (x) = >   tierRank[x.tier] ?? 9;
  const m = (x) = >   impactRank[x.impact] ?? 9;
  if (by ===  " impact " ) return (m(a) - m(b)) || (t(a) - t(b)) || depCmp(a, b);
  return (t(a) - t(b)) || (m(a) - m(b)) || depCmp(a, b);   // default: tier first, impact tiebreak
};
// Level Separation: Story-level (L4) is THE ranking this command reports/moves by default.
// Epic/Project-level (L2-3) is sorted into its own separate list — never merged with storyLevelSig,
// so an Epic never competes against a single Story on the same priority axis.
storyLevelSig.sort(cmp);
if (opts.includeEpics) upperLevelSig.sort(cmp);            // only when --include-epics is passed
// depCmp: issues whose parent appears earlier (blockers/Epics) rank ahead; stable otherwise.

// moveIssueToPipeline cannot set an index. To approximate top-to-bottom order,
// re-move issues in DESCENDING priority (P0 first) so the highest land on top.
// Labels are immutable, so the durable rerank signal = pipeline membership + ranking.md.
// Level Separation: only storyLevelSig moves by default — Epic/Project issues are left
// untouched unless --include-epics is passed, and even then move as their own pass
// (never interleaved with Story issues in the same sort/move sequence).
if (!opts.dryRun) {
  const movable = opts.includeEpics ? [...storyLevelSig, ...upperLevelSig] : storyLevelSig;
  for (const s of movable) {                                 // each sub-list already sorted P0-first
    const target = backlogPipelines.find(p = >   p.name === s.pipeline);
    if (!target) throw new Error(`타깃 파이프라인  " ${s.pipeline} "   미해석. 라이브: ${workspace.pipelines.map(p = >   p.name).join( " ,  " )}`);
    await mcp__zenhub__moveIssueToPipeline({ issueId: s.id, pipelineId: target.id });
  }
}

const team = await mcp__zenhub__getTeamMembers();           // group ranked issues per assignee/team
// flag any team holding  >   N p0 issues (default N=3) as overloaded in the report.

// Write .pipeline/ranking.md with TWO sections (never merged into one table):
//   ## Story-level ranking   — storyLevelSig, columns: rank | #issue | tier | impact | reason
//   ## Epic/Project ranking  — upperLevelSig, same columns (present only when --include-epics)
// --dry-run → print the same tables to stdout, write nothing.

// Repos + pipelines (source of repoIds and pipeline.id)
const workspace = await mcp__zenhub__getWorkspacePipelinesAndRepositories();
const repoIds = workspace.githubRepositories.map(r = >   r.id);

// Backlog contents (repositoryIds REQUIRED)
await mcp__zenhub__getIssuesInPipeline({ pipelineId, repositoryIds: repoIds });

// Loose issues for --scope all (no getIssue / getChildrenOfParent exist)
await mcp__zenhub__searchLatestIssues({ query:  " #1413 "   });   // or  " parent: < graphqlId > " 
 // ⚠️ GD-04:  " parent: < graphqlId > "   only scans the  " latest 20 issues "   — old/untouched
// children silently drop out. Fine for this loose-issue survey; never use it as a
// completeness check. See commands/run.md Step 0.6 for the reliable alternative.

// Reorder approximation (no position param)
await mcp__zenhub__moveIssueToPipeline({ issueId, pipelineId });

// Team grouping
await mcp__zenhub__getTeamMembers();