@h-rig/core 0.0.6-alpha.132 → 0.0.6-alpha.134

package/dist/src/index.js

@@ -2358,6 +2358,51 @@ function selectUserInputsForWorkspace(snapshot, workspaceId) {
   const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
   return (snapshot.userInputs ?? []).filter((request) => runIds.has(request.runId));
 }
+// packages/core/src/taskScore.ts
+var ROLE_WEIGHT = {
+  architect: 25,
+  extractor: 10
+};
+var CRITICALITY_WEIGHT = {
+  core: 20,
+  high: 10,
+  normal: 0
+};
+function finiteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function scoreTask(input) {
+  const priority = finiteNumber(input.priority, 3);
+  const unblockCount = Math.max(0, finiteNumber(input.unblockCount, 0));
+  const roleWeight = input.role ? ROLE_WEIGHT[input.role] ?? 0 : 0;
+  const criticalityWeight = input.criticality ? CRITICALITY_WEIGHT[input.criticality] ?? 0 : 0;
+  const validationWeight = (input.validation ?? []).some((entry) => entry.includes("test-contract") || entry.includes("test-boundary")) ? 8 : 0;
+  const queueWeight = finiteNumber(input.queueWeight, 0);
+  return unblockCount * 100 + (10 - priority) + roleWeight + criticalityWeight + validationWeight + queueWeight;
+}
+function rankTasks(tasks, scoreInput, idOf) {
+  return tasks.map((task) => {
+    const input = scoreInput(task);
+    return {
+      task,
+      score: scoreTask(input),
+      priority: finiteNumber(input.priority, 3),
+      unblockCount: Math.max(0, finiteNumber(input.unblockCount, 0))
+    };
+  }).toSorted((left, right) => {
+    const scoreDelta = right.score - left.score;
+    if (scoreDelta !== 0)
+      return scoreDelta;
+    const unblockDelta = right.unblockCount - left.unblockCount;
+    if (unblockDelta !== 0)
+      return unblockDelta;
+    const priorityDelta = left.priority - right.priority;
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return idOf(left.task).localeCompare(idOf(right.task));
+  });
+}
+
 // packages/core/src/taskGraph.ts
 function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2382,6 +2427,9 @@ function readTaskMetadataStringList(task, key) {
   }
   return [];
 }
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
 function readTaskDependencyRefs(task) {
   return unique([
     ...readTaskMetadataStringList(task, "dependencies"),
@@ -2399,6 +2447,32 @@ function readTaskSourceIssueId(task) {
   const rigMetadata = isObjectRecord2(metadata?._rig) ? metadata._rig : null;
   return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
 }
+function readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function isScopeList(input) {
+  return Array.isArray(input);
+}
+function normalizeScopeInput(input) {
+  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
+}
+function disjointScope(left, right) {
+  const leftScope = new Set(normalizeScopeInput(left));
+  if (leftScope.size === 0)
+    return true;
+  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
+}
 function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
   if (tasksById.has(ref))
     return ref;
@@ -2427,7 +2501,7 @@ function computeTaskBlockingDepths(tasks) {
     if (!task)
       return 0;
     stack.add(taskId);
-    const blockers = readTaskDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
     const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
     stack.delete(taskId);
     memo.set(taskId, depth);
@@ -2470,6 +2544,39 @@ function isTaskRunnableStatus(status) {
 function priorityValue(task) {
   return typeof task.priority === "number" && Number.isFinite(task.priority) ? task.priority : Number.MAX_SAFE_INTEGER;
 }
+function readTaskRole(task) {
+  if (typeof task.role === "string" && task.role.trim())
+    return task.role.trim();
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
+}
+function readTaskCriticality(task) {
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return typeof metadata?.criticality === "string" && metadata.criticality.trim() ? metadata.criticality.trim() : null;
+}
+function readTaskValidationKeys(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.validationKeys);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return readStringList(metadata?.validation);
+}
+function readTaskQueueWeight(task) {
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  const queueWeight = metadata?.queueWeight ?? metadata?.queue_weight;
+  return typeof queueWeight === "number" && Number.isFinite(queueWeight) ? queueWeight : 0;
+}
+function scoreInputForTask(task, unblockCount) {
+  return {
+    priority: task.priority,
+    unblockCount,
+    role: readTaskRole(task),
+    criticality: readTaskCriticality(task),
+    validation: readTaskValidationKeys(task),
+    queueWeight: readTaskQueueWeight(task)
+  };
+}
 function computeTaskDependencyBadges(tasks) {
   const index = buildTaskReferenceIndex(tasks);
   const blockingDepths = computeTaskBlockingDepths(tasks);
@@ -2479,7 +2586,7 @@ function computeTaskDependencyBadges(tasks) {
   for (const task of tasks) {
     const dependencyIds = [];
     const unresolvedRefs = [];
-    for (const ref of readTaskDependencyRefs(task)) {
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
       const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
       if (dependencyId && dependencyId !== task.id) {
         dependencyIds.push(dependencyId);
@@ -2566,6 +2673,51 @@ function selectNextReadyTaskByPriority(tasks, options = {}) {
   });
   return candidates[0] ?? null;
 }
+function rankReadyTasks(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const activeTaskIds = new Set(options.activeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges(tasks);
+  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
+  const openBlockCount = (task) => (badges.get(task.id)?.blocks ?? []).filter((blockedTaskId) => {
+    const blockedTask = tasksById.get(blockedTaskId);
+    return blockedTask ? !isTaskTerminalStatus(blockedTask.status) : false;
+  }).length;
+  const readyTasks = tasks.filter((task) => !excluded.has(task.id)).filter((task) => !activeTaskIds.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true);
+  const maxUnblockCount = Math.max(0, ...readyTasks.map(openBlockCount));
+  const selectedByMode = readyTasks.filter((task) => {
+    const unblockCount = openBlockCount(task);
+    if (options.selection === "blocking-only")
+      return unblockCount > 0;
+    if (options.selection === "max-unblock")
+      return maxUnblockCount > 0 && unblockCount === maxUnblockCount;
+    return true;
+  });
+  return rankTasks(selectedByMode, (task) => scoreInputForTask(task, openBlockCount(task)), (task) => task.id).map((entry) => ({
+    task: entry.task,
+    score: entry.score,
+    priority: entry.priority,
+    unblockCount: entry.unblockCount,
+    scope: readTaskScope(entry.task)
+  }));
+}
+function selectRankedReadyTasks(tasks, options = {}) {
+  const ranked = rankReadyTasks(tasks, options);
+  if (options.requireDisjointScopes !== true && !options.disjointWithScopes) {
+    return ranked.slice(0, options.limit).map((entry) => entry.task);
+  }
+  const occupiedScopes = new Set(options.disjointWithScopes ?? []);
+  const selected = [];
+  for (const entry of ranked) {
+    if (entry.scope.some((scope) => occupiedScopes.has(scope)))
+      continue;
+    selected.push(entry.task);
+    for (const scope of entry.scope)
+      occupiedScopes.add(scope);
+    if (options.limit !== undefined && selected.length >= options.limit)
+      break;
+  }
+  return selected;
+}
 // packages/core/src/taskGraphCodes.ts
 var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
 function extractTaskCode(title) {
@@ -2610,7 +2762,10 @@ function isObjectRecord3(value) {
 }
 function readIssueType(task) {
   const metadata = isObjectRecord3(task.metadata) ? task.metadata : null;
-  return typeof metadata?.issueType === "string" ? metadata.issueType : null;
+  if (typeof metadata?.issueType === "string")
+    return metadata.issueType;
+  const raw = isObjectRecord3(metadata?.raw) ? metadata.raw : null;
+  return typeof raw?.issueType === "string" ? raw.issueType : null;
 }
 function isGraphTask(task) {
   return readIssueType(task) !== "epic";
@@ -2857,6 +3012,7 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
         const artifactCount = (snapshot?.artifacts ?? []).filter((artifact) => runIds.has(artifact.runId)).length;
         nodes.push({
           id: task.id,
+          taskId: task.id,
           task,
           rowKey,
           rowLabel: rowLabelByKey.get(rowKey) ?? rowKey,
@@ -2891,6 +3047,645 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
     taskCount: graphTasks.length
   };
 }
+// packages/core/src/stageResolve.ts
+class PipelineUnresolvableError extends Error {
+  cycles;
+  contributors;
+  constructor(message, cycles, contributors) {
+    super(message);
+    this.name = "PipelineUnresolvableError";
+    this.cycles = cycles;
+    this.contributors = contributors;
+  }
+}
+function uniqueSorted(values) {
+  return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function wrapperForMutation(mutation) {
+  return "wrapper" in mutation ? mutation.wrapper : mutation.around;
+}
+function contributorOf(mutation) {
+  if (mutation.contributedBy?.trim())
+    return mutation.contributedBy;
+  if (mutation.op === "wrap") {
+    const wrapper = wrapperForMutation(mutation);
+    if (wrapper.id?.trim())
+      return wrapper.id;
+  }
+  return "anonymous";
+}
+function stableMutationCompare(left, right) {
+  const leftTarget = left.op === "insert" ? left.stage.id : left.id;
+  const rightTarget = right.op === "insert" ? right.stage.id : right.id;
+  const targetDelta = leftTarget.localeCompare(rightTarget);
+  if (targetDelta !== 0)
+    return targetDelta;
+  return contributorOf(left).localeCompare(contributorOf(right));
+}
+function ensureUniqueStageIds(stages) {
+  const seen = new Set;
+  for (const stage of stages) {
+    if (seen.has(stage.id)) {
+      throw new PipelineUnresolvableError(`Duplicate stage id: ${stage.id}`, [], []);
+    }
+    seen.add(stage.id);
+  }
+}
+function assertNoDuplicateMutationTargets(mutations, op) {
+  const seen = new Map;
+  for (const mutation of mutations.filter((entry) => entry.op === op)) {
+    const id = mutation.op === "insert" ? mutation.stage.id : mutation.id;
+    const previous = seen.get(id);
+    if (previous) {
+      throw new PipelineUnresolvableError(`Duplicate ${op} mutation for stage ${id}: ${previous}, ${contributorOf(mutation)}`, [], uniqueSorted([previous, contributorOf(mutation)]));
+    }
+    seen.set(id, contributorOf(mutation));
+  }
+}
+function hasProtectedGrant(grants, stageId, pluginId, op) {
+  return grants.some((grant) => grant.stageId === stageId && grant.pluginId === pluginId && (grant.op === undefined || grant.op === op));
+}
+function mergeAnchors(current, incoming) {
+  return uniqueSorted([...current, ...incoming ?? []]);
+}
+function stagePriority(stage) {
+  return typeof stage.priority === "number" && Number.isFinite(stage.priority) ? stage.priority : 0;
+}
+function readyCompare(states) {
+  return (left, right) => {
+    const leftState = states.get(left);
+    const rightState = states.get(right);
+    const priorityDelta = stagePriority(rightState?.stage ?? { id: right }) - stagePriority(leftState?.stage ?? { id: left });
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    if (leftState?.baseIndex !== null && rightState?.baseIndex !== null && leftState?.baseIndex !== rightState?.baseIndex) {
+      return (leftState?.baseIndex ?? 0) - (rightState?.baseIndex ?? 0);
+    }
+    if (leftState?.baseIndex !== null && rightState?.baseIndex === null)
+      return -1;
+    if (leftState?.baseIndex === null && rightState?.baseIndex !== null)
+      return 1;
+    return left.localeCompare(right);
+  };
+}
+function findCycles(nodes, edges) {
+  const adjacency = new Map;
+  for (const node of nodes)
+    adjacency.set(node, []);
+  for (const edge of edges)
+    adjacency.get(edge.from)?.push(edge.to);
+  for (const targets of adjacency.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  let nextIndex = 0;
+  const indexByNode = new Map;
+  const lowByNode = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const cycles = [];
+  const visit = (node) => {
+    indexByNode.set(node, nextIndex);
+    lowByNode.set(node, nextIndex);
+    nextIndex += 1;
+    stack.push(node);
+    onStack.add(node);
+    for (const target of adjacency.get(node) ?? []) {
+      if (!indexByNode.has(target)) {
+        visit(target);
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, lowByNode.get(target) ?? 0));
+      } else if (onStack.has(target)) {
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, indexByNode.get(target) ?? 0));
+      }
+    }
+    if (lowByNode.get(node) !== indexByNode.get(node))
+      return;
+    const component = [];
+    let current;
+    do {
+      current = stack.pop();
+      if (current) {
+        onStack.delete(current);
+        component.push(current);
+      }
+    } while (current && current !== node);
+    const hasSelfLoop = edges.some((edge) => edge.from === node && edge.to === node);
+    if (component.length > 1 || hasSelfLoop) {
+      cycles.push(component.sort((left, right) => left.localeCompare(right)));
+    }
+  };
+  for (const node of [...nodes].sort((left, right) => left.localeCompare(right))) {
+    if (!indexByNode.has(node))
+      visit(node);
+  }
+  return cycles.sort((left, right) => left.join("\x00").localeCompare(right.join("\x00")));
+}
+function topologicalOrder(states, edges) {
+  const nodes = [...states.keys()];
+  const outgoing = new Map;
+  const indegree = new Map;
+  for (const node of nodes) {
+    outgoing.set(node, []);
+    indegree.set(node, 0);
+  }
+  for (const edge of edges) {
+    outgoing.get(edge.from)?.push(edge.to);
+    indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+  }
+  for (const targets of outgoing.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  const compare = readyCompare(states);
+  const ready = nodes.filter((node) => (indegree.get(node) ?? 0) === 0).sort(compare);
+  const order = [];
+  while (ready.length > 0) {
+    const node = ready.shift();
+    if (!node)
+      break;
+    order.push(node);
+    for (const target of outgoing.get(node) ?? []) {
+      const next = (indegree.get(target) ?? 0) - 1;
+      indegree.set(target, next);
+      if (next === 0) {
+        ready.push(target);
+        ready.sort(compare);
+      }
+    }
+  }
+  if (order.length === nodes.length)
+    return order;
+  const cycles = findCycles(nodes, edges);
+  const cycleMembers = new Set(cycles.flat());
+  const contributors = uniqueSorted(edges.filter((edge) => cycleMembers.has(edge.from) && cycleMembers.has(edge.to)).flatMap((edge) => edge.contributors));
+  throw new PipelineUnresolvableError(`Stage pipeline has unresolved cycle: ${cycles.map((cycle) => cycle.join(" -> ")).join("; ")}`, cycles, contributors);
+}
+function composeStageWrappers(state) {
+  const wrappers = state.wrappers.toSorted((left, right) => {
+    const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return left.contributedBy.localeCompare(right.contributedBy);
+  });
+  let stage = state.stage;
+  for (const wrapper of wrappers.toReversed()) {
+    if (wrapper.wrapper.apply)
+      stage = wrapper.wrapper.apply(stage);
+  }
+  return stage;
+}
+function resolveStagePipeline(input) {
+  ensureUniqueStageIds(input.defaultStages);
+  const mutations = [...input.mutations ?? []];
+  assertNoDuplicateMutationTargets(mutations, "insert");
+  assertNoDuplicateMutationTargets(mutations, "replace");
+  const grants = input.protectedStageGrants ?? [];
+  const states = new Map;
+  const removedStates = new Map;
+  for (const [index, stage] of input.defaultStages.entries()) {
+    states.set(stage.id, {
+      stage,
+      before: [...stage.before ?? []],
+      after: [...stage.after ?? []],
+      baseIndex: index,
+      contributedBy: "default",
+      wrappers: [],
+      droppedAnchors: [],
+      isProtected: stage.protected === true
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "remove").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    if (!state)
+      continue;
+    if (state.isProtected && !hasProtectedGrant(grants, mutation.id, contributor, "remove")) {
+      throw new PipelineUnresolvableError(`Protected stage ${mutation.id} cannot be removed by ${contributor} without an explicit grant`, [], [contributor]);
+    }
+    const removedState = {
+      ...state,
+      removedBy: contributor,
+      ...state.isProtected ? { grantUsedBy: contributor } : {}
+    };
+    removedStates.set(mutation.id, removedState);
+    states.delete(mutation.id);
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "replace").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    if (!state)
+      continue;
+    if (state.isProtected && !hasProtectedGrant(grants, mutation.id, contributor, "replace")) {
+      throw new PipelineUnresolvableError(`Protected stage ${mutation.id} cannot be replaced by ${contributor} without an explicit grant`, [], [contributor]);
+    }
+    const replacement = { ...mutation.stage, id: mutation.id };
+    states.set(mutation.id, {
+      ...state,
+      stage: replacement,
+      before: mutation.stage.before ? [...mutation.stage.before] : state.before,
+      after: mutation.stage.after ? [...mutation.stage.after] : state.after,
+      replacedBy: contributor,
+      contributedBy: state.contributedBy,
+      isProtected: mutation.stage.protected ?? state.isProtected,
+      ...state.isProtected ? { grantUsedBy: contributor } : {}
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "insert").sort(stableMutationCompare)) {
+    const contributor = contributorOf(mutation);
+    if (states.has(mutation.stage.id)) {
+      throw new PipelineUnresolvableError(`Inserted stage ${mutation.stage.id} conflicts with an existing stage`, [], [contributor]);
+    }
+    states.set(mutation.stage.id, {
+      stage: mutation.stage,
+      before: [...mutation.stage.before ?? []],
+      after: [...mutation.stage.after ?? []],
+      baseIndex: null,
+      contributedBy: contributor,
+      wrappers: [],
+      droppedAnchors: [],
+      isProtected: mutation.stage.protected === true
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "reorder").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    if (!state)
+      continue;
+    states.set(mutation.id, {
+      ...state,
+      before: mergeAnchors(state.before, mutation.before),
+      after: mergeAnchors(state.after, mutation.after)
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "wrap").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    const wrapper = wrapperForMutation(mutation);
+    if (!state)
+      continue;
+    states.set(mutation.id, {
+      ...state,
+      wrappers: [...state.wrappers, { contributedBy: contributor, wrapper }]
+    });
+  }
+  const contributorsForAnchor = (stageId, direction, anchor, state) => {
+    const contributors = new Set;
+    if (state.replacedBy)
+      contributors.add(state.replacedBy);
+    for (const mutation of mutations) {
+      if (mutation.op === "reorder" && mutation.id === stageId && (direction === "before" ? mutation.before : mutation.after)?.includes(anchor)) {
+        contributors.add(contributorOf(mutation));
+      }
+      if (mutation.op === "insert" && mutation.stage.id === stageId && (direction === "before" ? mutation.stage.before : mutation.stage.after)?.includes(anchor)) {
+        contributors.add(contributorOf(mutation));
+      }
+    }
+    if (contributors.size === 0)
+      contributors.add(state.contributedBy);
+    return uniqueSorted(contributors);
+  };
+  const edges = [];
+  for (const [stageId, state] of states) {
+    const before = [];
+    const after = [];
+    for (const anchor of state.before) {
+      if (states.has(anchor))
+        before.push(anchor);
+      else {
+        const removed = removedStates.get(anchor);
+        state.droppedAnchors.push({
+          stageId,
+          anchor,
+          direction: "before",
+          reason: removed ? "removed" : "missing",
+          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
+        });
+      }
+    }
+    for (const anchor of state.after) {
+      if (states.has(anchor))
+        after.push(anchor);
+      else {
+        const removed = removedStates.get(anchor);
+        state.droppedAnchors.push({
+          stageId,
+          anchor,
+          direction: "after",
+          reason: removed ? "removed" : "missing",
+          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
+        });
+      }
+    }
+    state.before = uniqueSorted(before);
+    state.after = uniqueSorted(after);
+    for (const target of state.before)
+      edges.push({ from: stageId, to: target, contributors: contributorsForAnchor(stageId, "before", target, state) });
+    for (const source of state.after)
+      edges.push({ from: source, to: stageId, contributors: contributorsForAnchor(stageId, "after", source, state) });
+  }
+  const order = topologicalOrder(states, edges);
+  const stages = [];
+  const record = [];
+  for (const id of order) {
+    const state = states.get(id);
+    if (!state)
+      continue;
+    stages.push(composeStageWrappers(state));
+    const wrappedBy = state.wrappers.toSorted((left, right) => {
+      const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
+      if (priorityDelta !== 0)
+        return priorityDelta;
+      return left.contributedBy.localeCompare(right.contributedBy);
+    }).map((wrapper) => wrapper.contributedBy);
+    record.push({
+      stageId: id,
+      contributedBy: state.contributedBy,
+      ...state.replacedBy ? { replacedBy: state.replacedBy } : {},
+      ...wrappedBy.length > 0 ? { wrappedBy } : {},
+      ...state.droppedAnchors.length > 0 ? { droppedAnchors: state.droppedAnchors.toSorted((left, right) => left.anchor.localeCompare(right.anchor)) } : {},
+      isProtected: state.isProtected,
+      ...state.grantUsedBy ? { grantUsedBy: state.grantUsedBy } : {}
+    });
+  }
+  record.push(...[...removedStates.entries()].toSorted((left, right) => {
+    const leftIndex = left[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
+    const rightIndex = right[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
+    if (leftIndex !== rightIndex)
+      return leftIndex - rightIndex;
+    return left[0].localeCompare(right[0]);
+  }).map(([stageId, state]) => ({
+    stageId,
+    contributedBy: state.contributedBy,
+    ...state.removedBy ? { removedBy: state.removedBy } : {},
+    isProtected: state.isProtected,
+    ...state.grantUsedBy ? { grantUsedBy: state.grantUsedBy } : {}
+  })));
+  return { stages, order, record, cycles: [] };
+}
+// packages/core/src/dependencyGraph.ts
+function uniqueSorted2(values) {
+  return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function deriveGraphId(tasks) {
+  const basis = tasks.map((task) => String(task.id)).toSorted((left, right) => left.localeCompare(right)).join("|");
+  let hash = 2166136261;
+  for (let index = 0;index < basis.length; index += 1) {
+    hash ^= basis.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `graph-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function dedupeEdges(edges) {
+  const byKey = new Map;
+  for (const edge of edges) {
+    byKey.set(`${edge.type}\x00${edge.fromTaskId}\x00${edge.toTaskId}`, edge);
+  }
+  return [...byKey.values()].toSorted((left, right) => {
+    const typeDelta = left.type.localeCompare(right.type);
+    if (typeDelta !== 0)
+      return typeDelta;
+    const fromDelta = left.fromTaskId.localeCompare(right.fromTaskId);
+    if (fromDelta !== 0)
+      return fromDelta;
+    return left.toTaskId.localeCompare(right.toTaskId);
+  });
+}
+function detectBlockingCycles(tasks, edges) {
+  const taskIds = tasks.map((task) => String(task.id)).toSorted((left, right) => left.localeCompare(right));
+  const adjacency = new Map;
+  for (const taskId of taskIds)
+    adjacency.set(taskId, []);
+  for (const edge of edges) {
+    if (edge.type === "blocks")
+      adjacency.get(edge.fromTaskId)?.push(edge.toTaskId);
+  }
+  for (const targets of adjacency.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  let nextIndex = 0;
+  const indexByNode = new Map;
+  const lowByNode = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const cycles = [];
+  const visit = (node) => {
+    indexByNode.set(node, nextIndex);
+    lowByNode.set(node, nextIndex);
+    nextIndex += 1;
+    stack.push(node);
+    onStack.add(node);
+    for (const target of adjacency.get(node) ?? []) {
+      if (!indexByNode.has(target)) {
+        visit(target);
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, lowByNode.get(target) ?? 0));
+      } else if (onStack.has(target)) {
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, indexByNode.get(target) ?? 0));
+      }
+    }
+    if (lowByNode.get(node) !== indexByNode.get(node))
+      return;
+    const component = [];
+    let current;
+    do {
+      current = stack.pop();
+      if (current) {
+        onStack.delete(current);
+        component.push(current);
+      }
+    } while (current && current !== node);
+    const selfLoop = (adjacency.get(node) ?? []).includes(node);
+    if (component.length > 1 || selfLoop)
+      cycles.push(component.sort((left, right) => left.localeCompare(right)));
+  };
+  for (const taskId of taskIds) {
+    if (!indexByNode.has(taskId))
+      visit(taskId);
+  }
+  return cycles.sort((left, right) => left.join("\x00").localeCompare(right.join("\x00")));
+}
+function buildDependencyGraphModel(tasks, options = {}) {
+  const badges = computeTaskDependencyBadges(tasks);
+  const index = buildTaskReferenceIndex(tasks);
+  const edges = [];
+  const unresolvedRefs = [];
+  for (const task of tasks) {
+    for (const ref of readTaskMetadataStringList(task, "dependencies")) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId)
+        edges.push({ fromTaskId: dependencyId, toTaskId: String(task.id), type: "blocks" });
+      else
+        unresolvedRefs.push(ref);
+    }
+    for (const ref of readTaskMetadataStringList(task, "parentChildDeps")) {
+      const parentId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (parentId)
+        edges.push({ fromTaskId: parentId, toTaskId: String(task.id), type: "parent-child" });
+      else
+        unresolvedRefs.push(ref);
+    }
+  }
+  const dedupedEdges = dedupeEdges(edges);
+  const nodes = tasks.map((task) => {
+    const summary = badges.get(task.id);
+    const assignees = readTaskAssigneeLogins(task);
+    const groupKey = extractTaskGroupKey(task.title);
+    return {
+      taskId: String(task.id),
+      title: task.title,
+      status: task.status,
+      priority: task.priority,
+      assignee: assignees[0] ?? null,
+      blockedBy: summary?.blockedBy ?? [],
+      blocks: summary?.blocks ?? [],
+      blockingDepth: summary?.blockingDepth ?? 0,
+      blockerClass: null,
+      actionRiskTier: null,
+      epicKey: groupKey,
+      groupKey,
+      externalId: task.externalId,
+      sourceIssueId: task.sourceIssueId ?? null,
+      scope: task.scope,
+      validationKeys: task.validationKeys
+    };
+  }).toSorted((left, right) => left.taskId.localeCompare(right.taskId));
+  return {
+    graphId: options.graphId ?? deriveGraphId(tasks),
+    nodes,
+    edges: dedupedEdges,
+    layout: buildTaskGraphLayout(options.snapshot ?? null, tasks, { showParentChild: options.showParentChild ?? true }),
+    cycles: detectBlockingCycles(tasks, dedupedEdges),
+    unresolvedRefs: uniqueSorted2(unresolvedRefs),
+    degraded: false,
+    generatedAt: options.generatedAt ?? new Date().toISOString()
+  };
+}
+// packages/core/src/rollups.ts
+import { isOperatorActiveRunStatus } from "@rig/contracts";
+var UNASSIGNED_EPIC = "(unassigned-epic)";
+var UNASSIGNED_ASSIGNEE = "(unassigned)";
+var HUMAN_BLOCKER_CLASSES = {
+  "human-decision": true,
+  "human-approval": true,
+  "external-input": true,
+  unknown: true
+};
+function isObjectRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readIssueType2(task) {
+  const metadata = isObjectRecord4(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord4(metadata?.raw) ? metadata.raw : null;
+  const value = raw?.issueType ?? metadata?.issueType;
+  return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : null;
+}
+function isEpicTask(task) {
+  return readIssueType2(task) === "epic";
+}
+function isInFlightTaskStatus(status) {
+  switch (status) {
+    case "queued":
+    case "running":
+    case "in_progress":
+    case "under_review":
+      return true;
+    default:
+      return false;
+  }
+}
+function epicKeyForTask(task, tasksById, resolve) {
+  const parentRef = readTaskMetadataStringList(task, "parentChildDeps")[0];
+  const parentId = parentRef ? resolve(parentRef) : null;
+  const parent = parentId ? tasksById.get(parentId) : null;
+  if (parent)
+    return extractTaskGroupKey(parent.title) ?? parent.title ?? parent.id;
+  return extractTaskGroupKey(task.title) ?? UNASSIGNED_EPIC;
+}
+function rollupByEpic(tasks, classifications = new Map) {
+  const index = buildTaskReferenceIndex(tasks);
+  const badges = computeTaskDependencyBadges(tasks);
+  const resolve = (ref) => resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+  const buckets = new Map;
+  for (const task of tasks) {
+    if (isEpicTask(task))
+      continue;
+    const epicKey = epicKeyForTask(task, index.tasksById, resolve);
+    const current = buckets.get(epicKey) ?? {
+      total: 0,
+      completed: 0,
+      blockedCount: 0,
+      humanBlockedCount: 0,
+      inFlightCount: 0,
+      byStatus: {}
+    };
+    current.total += 1;
+    if (isTaskTerminalStatus(task.status))
+      current.completed += 1;
+    if (badges.get(task.id)?.blocked === true)
+      current.blockedCount += 1;
+    if (isInFlightTaskStatus(task.status))
+      current.inFlightCount += 1;
+    const classification = classifications.get(task.id);
+    if (classification && HUMAN_BLOCKER_CLASSES[classification])
+      current.humanBlockedCount += 1;
+    current.byStatus[task.status] = (current.byStatus[task.status] ?? 0) + 1;
+    buckets.set(epicKey, current);
+  }
+  return [...buckets.entries()].map(([epicKey, bucket]) => ({
+    epicKey,
+    total: bucket.total,
+    percentComplete: bucket.total === 0 ? 0 : Math.round(100 * bucket.completed / bucket.total),
+    blockedCount: bucket.blockedCount,
+    humanBlockedCount: bucket.humanBlockedCount,
+    inFlightCount: bucket.inFlightCount,
+    byStatus: Object.fromEntries(Object.entries(bucket.byStatus).sort(([left], [right]) => left.localeCompare(right)))
+  })).toSorted((left, right) => left.epicKey.localeCompare(right.epicKey));
+}
+function assigneesForTask(task) {
+  const assignees = readTaskAssigneeLogins(task);
+  return assignees.length > 0 ? assignees : [UNASSIGNED_ASSIGNEE];
+}
+function rollupByAssignee(tasks, runs) {
+  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
+  const badges = computeTaskDependencyBadges(tasks);
+  const buckets = new Map;
+  const ensureBucket = (assignee) => {
+    const existing = buckets.get(assignee);
+    if (existing)
+      return existing;
+    const created = { openTaskCount: 0, inFlightRunIds: new Set, prsAwaitingReview: 0, blockers: new Set };
+    buckets.set(assignee, created);
+    return created;
+  };
+  for (const task of tasks) {
+    if (isEpicTask(task))
+      continue;
+    for (const assignee of assigneesForTask(task)) {
+      const bucket = ensureBucket(assignee);
+      if (!isTaskTerminalStatus(task.status))
+        bucket.openTaskCount += 1;
+      if (badges.get(task.id)?.blocked === true)
+        bucket.blockers.add(task.id);
+      if (task.status === "under_review")
+        bucket.prsAwaitingReview += 1;
+    }
+  }
+  for (const run of runs) {
+    const taskId = run.record.taskId;
+    const task = taskId ? tasksById.get(taskId) : null;
+    if (!task)
+      continue;
+    if (isEpicTask(task))
+      continue;
+    for (const assignee of assigneesForTask(task)) {
+      const bucket = ensureBucket(assignee);
+      if (run.status && isOperatorActiveRunStatus(run.status))
+        bucket.inFlightRunIds.add(run.record.runId ?? `${String(task.id)}:${run.lastSeq}`);
+      if (run.status === "reviewing" && run.record.prUrl)
+        bucket.prsAwaitingReview += 1;
+    }
+  }
+  return [...buckets.entries()].map(([assignee, bucket]) => ({
+    assignee,
+    openTaskCount: bucket.openTaskCount,
+    inFlightRunCount: bucket.inFlightRunIds.size,
+    prsAwaitingReview: bucket.prsAwaitingReview,
+    blockers: [...bucket.blockers].toSorted((left, right) => String(left).localeCompare(String(right)))
+  })).toSorted((left, right) => left.assignee.localeCompare(right.assignee));
+}
 
 // packages/core/src/index.ts
 var RIG_CORE_PACKAGE = "@rig/core";
@@ -2911,6 +3706,7 @@ export {
   selectRunsForTask,
   selectRunsByTask,
   selectRun,
+  selectRankedReadyTasks,
   selectQueueForWorkspace,
   selectPrimaryWorkspace,
   selectPendingApprovals,
@@ -2920,11 +3716,19 @@ export {
   selectApprovalsForRun,
   selectAdhocRunsForWorkspace,
   selectAdhocRuns,
+  scoreTask,
+  rollupByEpic,
+  rollupByAssignee,
   resolveTaskReference,
+  resolveStagePipeline,
   readTaskSourceIssueId,
+  readTaskScope,
   readTaskMetadataStringList,
   readTaskDependencyRefs,
+  readTaskBlockingDependencyRefs,
   readTaskAssigneeLogins,
+  rankTasks,
+  rankReadyTasks,
   pruneQueueEntries,
   projectTaskStatusWithSessions,
   projectTaskStatusForGrouping,
@@ -2934,6 +3738,7 @@ export {
   isTaskTerminalStatus,
   extractTaskGroupKey,
   extractTaskCode,
+  disjointScope,
   definePlugin,
   defineConfig,
   createPluginHost,
@@ -2942,8 +3747,10 @@ export {
   buildTaskReferenceIndex,
   buildTaskGraphLayout,
   buildRigInitConfigSource,
+  buildDependencyGraphModel,
   applyEngineEvent as applyRigEvent,
   applyEngineEvents,
   applyEngineEvent,
-  RIG_CORE_PACKAGE
+  RIG_CORE_PACKAGE,
+  PipelineUnresolvableError
 };