@h-rig/dependency-graph-plugin 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/plugin.js

@@ -3,6 +3,1038 @@ var __require = import.meta.require;
 
 // packages/dependency-graph-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core/config";
+import { classifyWorkspaceBlockers } from "@rig/blocker-classifier-plugin";
+
+// packages/dependency-graph-plugin/src/graph-model/dependencyGraph.ts
+import { computeTaskDependencyBadges, readTaskMetadataStringList as readTaskMetadataStringList2, resolveTaskReference as resolveTaskReference2, buildTaskReferenceIndex as buildTaskReferenceIndex2 } from "@rig/contracts";
+
+// packages/dependency-graph-plugin/src/graph-model/taskGraphCodes.ts
+var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
+function extractTaskCode(title) {
+  const match = title.match(TASK_CODE_RE);
+  return match?.[1] ?? null;
+}
+function extractTaskGroupKey(title) {
+  const code = extractTaskCode(title);
+  if (!code)
+    return null;
+  const parts = code.split("-");
+  const suffix = parts.at(-1) ?? "";
+  if (/^\d+$/.test(suffix)) {
+    return parts.slice(0, -1).join("-");
+  }
+  return parts[0] ?? code;
+}
+function stripTaskCode(label) {
+  return label.replace(TASK_CODE_RE, "");
+}
+
+// packages/dependency-graph-plugin/src/graph-model/taskGraphLayout.ts
+import {
+  buildTaskReferenceIndex,
+  readTaskMetadataStringList,
+  resolveTaskReference
+} from "@rig/contracts";
+import {
+  selectPendingApprovals,
+  selectRunsByTask,
+  selectUserInputsForRun
+} from "@rig/read-model-plugin";
+var CARD_WIDTH = 200;
+var CARD_HEIGHT = 110;
+var CELL_V_PAD = 12;
+var CELL_H_PAD = 12;
+var ROW_GAP = 28;
+var COL_GAP = 40;
+var LANE_LABEL_W = 120;
+var STAGE_HDR_H = 32;
+var PALETTE = [
+  { bg: "#3a2d12", border: "#8d6b19", edge: "#d6a11d" },
+  { bg: "#102642", border: "#245fbf", edge: "#66a2ff" },
+  { bg: "#2c173f", border: "#7b39d4", edge: "#a76df5" },
+  { bg: "#112d1c", border: "#2d8f4e", edge: "#62d882" },
+  { bg: "#3a2314", border: "#c86d1c", edge: "#e69654" },
+  { bg: "#31152b", border: "#bf3d88", edge: "#f07ebb" },
+  { bg: "#132c35", border: "#1783a6", edge: "#53c4e5" },
+  { bg: "#26310f", border: "#6d9a19", edge: "#a7da42" }
+];
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readIssueType(task) {
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.issueType === "string")
+    return metadata.issueType;
+  const raw = isObjectRecord(metadata?.raw) ? metadata.raw : null;
+  return typeof raw?.issueType === "string" ? raw.issueType : null;
+}
+function isGraphTask(task) {
+  return readIssueType(task) !== "epic";
+}
+function findEpicAncestor(task, resolve, tasksById) {
+  const visited = new Set;
+  let current = task;
+  let epic = null;
+  while (!visited.has(current.id)) {
+    visited.add(current.id);
+    const parentRef = readTaskMetadataStringList(current, "parentChildDeps")[0];
+    if (!parentRef)
+      break;
+    const parentId = resolve(parentRef);
+    if (!parentId)
+      break;
+    const parent = tasksById.get(parentId);
+    if (!parent)
+      break;
+    if (readIssueType(parent) === "epic") {
+      epic = parent;
+    }
+    current = parent;
+  }
+  return epic;
+}
+function getRowKey(task, resolve, tasksById) {
+  const epic = findEpicAncestor(task, resolve, tasksById);
+  if (epic) {
+    return `group:${epic.id}`;
+  }
+  const codeGroup = extractTaskGroupKey(task.title);
+  if (codeGroup) {
+    return `code:${codeGroup}`;
+  }
+  return `type:${readIssueType(task) ?? "task"}`;
+}
+function getRowLabel(task, rowKey, resolve, tasksById) {
+  if (rowKey.startsWith("group:")) {
+    const groupId = rowKey.slice("group:".length);
+    return tasksById.get(groupId)?.title ?? groupId;
+  }
+  if (rowKey.startsWith("code:")) {
+    return rowKey.slice("code:".length);
+  }
+  const code = extractTaskCode(task.title);
+  if (code)
+    return code;
+  const issueType = readIssueType(task);
+  if (issueType === "task")
+    return "Tasks";
+  if (issueType)
+    return `${issueType[0]?.toUpperCase() ?? ""}${issueType.slice(1)}`;
+  const parentRef = readTaskMetadataStringList(task, "parentChildDeps")[0];
+  if (parentRef) {
+    const parentId = resolve(parentRef);
+    if (parentId) {
+      return tasksById.get(parentId)?.title ?? "Tasks";
+    }
+  }
+  return "Tasks";
+}
+function computeDepths(ids, edges) {
+  const blockers = new Map;
+  for (const edge of edges) {
+    if (!ids.has(edge.source) || !ids.has(edge.target))
+      continue;
+    const current = blockers.get(edge.target) ?? [];
+    current.push(edge.source);
+    blockers.set(edge.target, current);
+  }
+  const memo = new Map;
+  const visit = (id, stack) => {
+    const cached = memo.get(id);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(id))
+      return 0;
+    stack.add(id);
+    const deps = blockers.get(id);
+    if (!deps || deps.length === 0) {
+      memo.set(id, 0);
+      return 0;
+    }
+    let maxDepth = 0;
+    for (const dep of deps) {
+      maxDepth = Math.max(maxDepth, visit(dep, stack) + 1);
+    }
+    stack.delete(id);
+    memo.set(id, maxDepth);
+    return maxDepth;
+  };
+  for (const id of ids) {
+    visit(id, new Set);
+  }
+  return memo;
+}
+function buildTaskGraphLayout(snapshot, tasks, options) {
+  const showParentChild = options?.showParentChild ?? false;
+  const graphTasks = tasks.filter(isGraphTask);
+  if (graphTasks.length === 0) {
+    return {
+      lanes: [],
+      stages: [],
+      nodes: [],
+      edges: [],
+      totalWidth: 0,
+      totalHeight: 0,
+      taskCount: 0
+    };
+  }
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const resolve = (ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId);
+  const rows = new Map;
+  const rowLabelByKey = new Map;
+  for (const task of graphTasks) {
+    const rowKey = getRowKey(task, resolve, tasksById);
+    const current = rows.get(rowKey) ?? [];
+    current.push(task);
+    rows.set(rowKey, current);
+    if (!rowLabelByKey.has(rowKey)) {
+      rowLabelByKey.set(rowKey, getRowLabel(task, rowKey, resolve, tasksById));
+    }
+  }
+  const orderedRows = [...rows.entries()].sort((left, right) => {
+    if (left[1].length !== right[1].length)
+      return right[1].length - left[1].length;
+    return (rowLabelByKey.get(left[0]) ?? left[0]).localeCompare(rowLabelByKey.get(right[0]) ?? right[0]);
+  });
+  const rowIndexByKey = new Map(orderedRows.map(([key], index) => [key, index]));
+  const rowIndexByTaskId = new Map;
+  for (const task of graphTasks) {
+    rowIndexByTaskId.set(task.id, rowIndexByKey.get(getRowKey(task, resolve, tasksById)) ?? 0);
+  }
+  const blockingEdgesRaw = [];
+  const depsIn = new Map;
+  const depsOut = new Map;
+  const edges = [];
+  for (const task of graphTasks) {
+    for (const ref of readTaskMetadataStringList(task, "dependencies")) {
+      const sourceId = resolve(ref);
+      if (!sourceId)
+        continue;
+      blockingEdgesRaw.push({ source: sourceId, target: task.id });
+      depsOut.set(sourceId, (depsOut.get(sourceId) ?? 0) + 1);
+      depsIn.set(task.id, (depsIn.get(task.id) ?? 0) + 1);
+      const color = PALETTE[(rowIndexByTaskId.get(sourceId) ?? 0) % PALETTE.length].edge;
+      edges.push({
+        id: `blocking:${sourceId}:${task.id}`,
+        sourceId,
+        targetId: task.id,
+        color,
+        kind: "blocking"
+      });
+    }
+    if (!showParentChild)
+      continue;
+    for (const ref of readTaskMetadataStringList(task, "parentChildDeps")) {
+      const sourceId = resolve(ref);
+      if (!sourceId)
+        continue;
+      edges.push({
+        id: `parent:${sourceId}:${task.id}`,
+        sourceId,
+        targetId: task.id,
+        color: "#5b6472",
+        kind: "parent-child"
+      });
+    }
+  }
+  const graphTaskIds = new Set(graphTasks.map((task) => task.id));
+  const depths = computeDepths(graphTaskIds, blockingEdgesRaw);
+  const maxStage = Math.max(0, ...depths.values());
+  const rowMaxStack = new Array(orderedRows.length).fill(0);
+  const cells = new Map;
+  for (const task of graphTasks) {
+    const rowIndex = rowIndexByTaskId.get(task.id) ?? 0;
+    const stage = depths.get(task.id) ?? 0;
+    const key = `${rowIndex}:${stage}`;
+    const current = cells.get(key) ?? [];
+    current.push(task);
+    cells.set(key, current);
+  }
+  for (const [cellKey, cellTasks] of cells) {
+    const [rowIndexText] = cellKey.split(":");
+    const rowIndex = Number.parseInt(rowIndexText ?? "0", 10) || 0;
+    cellTasks.sort((left, right) => {
+      const leftFanout = depsOut.get(left.id) ?? 0;
+      const rightFanout = depsOut.get(right.id) ?? 0;
+      if (leftFanout !== rightFanout)
+        return rightFanout - leftFanout;
+      return left.title.localeCompare(right.title);
+    });
+    rowMaxStack[rowIndex] = Math.max(rowMaxStack[rowIndex] ?? 0, cellTasks.length);
+  }
+  const rowHeights = rowMaxStack.map((count) => Math.max(count, 1) * (CARD_HEIGHT + CELL_V_PAD) - CELL_V_PAD + CELL_V_PAD * 2);
+  const colWidths = new Array(maxStage + 1).fill(CARD_WIDTH + CELL_H_PAD * 2);
+  const colX = [];
+  let currentX = LANE_LABEL_W;
+  for (let index = 0;index <= maxStage; index += 1) {
+    colX.push(currentX);
+    currentX += (colWidths[index] ?? 0) + COL_GAP;
+  }
+  const totalWidth = currentX - COL_GAP;
+  const rowY = [];
+  let currentY = STAGE_HDR_H;
+  for (let rowIndex = 0;rowIndex < orderedRows.length; rowIndex += 1) {
+    rowY.push(currentY);
+    currentY += (rowHeights[rowIndex] ?? 0) + ROW_GAP;
+  }
+  const totalHeight = currentY - ROW_GAP;
+  const lanes = orderedRows.map(([rowKey, rowTasks], rowIndex) => ({
+    key: rowKey,
+    label: rowLabelByKey.get(rowKey) ?? rowKey,
+    rowIndex,
+    x: LANE_LABEL_W - 6,
+    y: (rowY[rowIndex] ?? 0) - 6,
+    width: totalWidth - LANE_LABEL_W + 12,
+    height: (rowHeights[rowIndex] ?? 0) + 12,
+    color: PALETTE[rowIndex % PALETTE.length].border,
+    taskCount: rowTasks.length
+  }));
+  const stages = Array.from({ length: maxStage + 1 }, (_, index) => ({
+    index,
+    label: index === 0 ? "Roots" : `Stage ${index}`,
+    x: (colX[index] ?? 0) + CELL_H_PAD,
+    width: CARD_WIDTH
+  }));
+  const pendingApprovalRunIds = new Set(selectPendingApprovals(snapshot).map((approval) => approval.runId));
+  const nodes = [];
+  for (const [rowIndex, [rowKey]] of orderedRows.entries()) {
+    for (let stage = 0;stage <= maxStage; stage += 1) {
+      const cellTasks = cells.get(`${rowIndex}:${stage}`) ?? [];
+      const baseX = (colX[stage] ?? 0) + CELL_H_PAD;
+      const baseY = (rowY[rowIndex] ?? 0) + CELL_V_PAD;
+      const palette = PALETTE[rowIndex % PALETTE.length];
+      for (const [stackIndex, task] of cellTasks.entries()) {
+        const runs = selectRunsByTask(snapshot, task.id);
+        const runIds = new Set(runs.map((run) => run.id));
+        const hasApprovals = runs.some((run) => pendingApprovalRunIds.has(run.id));
+        const hasPendingUserInput = runs.some((run) => selectUserInputsForRun(snapshot, run.id).some((request) => request.status === "pending"));
+        const hasRejectedReview = (snapshot?.reviews ?? []).some((review) => runIds.has(review.runId) && review.status === "rejected");
+        const hasFailedValidations = (snapshot?.validations ?? []).some((validation) => runIds.has(validation.runId) && validation.status === "failed");
+        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,
+          rowIndex,
+          stage,
+          x: baseX,
+          y: baseY + stackIndex * (CARD_HEIGHT + CELL_V_PAD),
+          width: CARD_WIDTH,
+          height: CARD_HEIGHT,
+          color: palette.border,
+          taskCode: extractTaskCode(task.title),
+          strippedTitle: stripTaskCode(task.title),
+          depsIn: depsIn.get(task.id) ?? 0,
+          depsOut: depsOut.get(task.id) ?? 0,
+          runCount: runs.length,
+          hasApprovals,
+          hasPendingUserInput,
+          hasRejectedReview,
+          hasFailedValidations,
+          artifactCount
+        });
+      }
+    }
+  }
+  return {
+    lanes,
+    stages,
+    nodes,
+    edges,
+    totalWidth,
+    totalHeight,
+    taskCount: graphTasks.length
+  };
+}
+
+// packages/dependency-graph-plugin/src/graph-model/dependencyGraph.ts
+import { readTaskAssigneeLogins } from "@rig/read-model-plugin";
+function uniqueSorted(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 = buildTaskReferenceIndex2(tasks);
+  const edges = [];
+  const unresolvedRefs = [];
+  for (const task of tasks) {
+    for (const ref of readTaskMetadataStringList2(task, "dependencies")) {
+      const dependencyId = resolveTaskReference2(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 readTaskMetadataStringList2(task, "parentChildDeps")) {
+      const parentId = resolveTaskReference2(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: uniqueSorted(unresolvedRefs),
+    degraded: false,
+    generatedAt: options.generatedAt ?? new Date().toISOString()
+  };
+}
+
+// packages/dependency-graph-plugin/src/graph.ts
+import { toTaskSummary } from "@rig/contracts";
+import { classifyTasks } from "@rig/blocker-classifier-plugin";
+function overlayLayoutRunState(model, runs) {
+  if (runs.length === 0)
+    return model.layout;
+  const runsByTask = new Map;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    runsByTask.set(run.taskId, [...runsByTask.get(run.taskId) ?? [], run]);
+  }
+  return {
+    ...model.layout,
+    nodes: model.layout.nodes.map((node) => {
+      const taskRuns = runsByTask.get(node.taskId) ?? [];
+      return {
+        ...node,
+        runCount: taskRuns.length,
+        hasApprovals: taskRuns.some((run) => run.pendingApprovals > 0),
+        hasPendingUserInput: taskRuns.some((run) => run.pendingInputs > 0),
+        hasRejectedReview: taskRuns.some((run) => run.status === "reviewing" && Boolean(run.errorSummary)),
+        hasFailedValidations: taskRuns.some((run) => run.status === "failed")
+      };
+    })
+  };
+}
+function buildWorkspaceDependencyGraph(input) {
+  const summaries = input.tasks.map((task) => toTaskSummary(task, input.workspaceId !== undefined ? { workspaceId: input.workspaceId } : {}));
+  const model = (input.projectDependencyGraph ?? buildDependencyGraphModel)(summaries, {
+    ...input.generatedAt !== undefined ? { generatedAt: input.generatedAt } : {},
+    ...input.graphId !== undefined ? { graphId: input.graphId } : {},
+    ...input.showParentChild !== undefined ? { showParentChild: input.showParentChild } : {}
+  });
+  const classifications = input.classifications ?? classifyTasks(input.tasks, input.runs ?? [], input.generatedAt !== undefined ? { generatedAt: input.generatedAt } : {}).byTaskId;
+  return {
+    ...model,
+    layout: overlayLayoutRunState(model, input.runs ?? []),
+    nodes: model.nodes.map((node) => {
+      const classification = classifications.get(node.taskId);
+      return {
+        ...node,
+        blockerClass: classification?.blockerClass ?? node.blockerClass,
+        actionRiskTier: classification?.actionRiskTier ?? null
+      };
+    })
+  };
+}
+async function getWorkspaceDependencyGraph(projectRoot, deps) {
+  const [tasks, runs, blockers] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([]),
+    deps.classifyBlockers ? deps.classifyBlockers(projectRoot) : Promise.resolve(null)
+  ]);
+  return buildWorkspaceDependencyGraph({
+    tasks,
+    runs,
+    ...blockers?.byTaskId !== undefined ? { classifications: blockers.byTaskId } : {},
+    ...deps.generatedAt !== undefined ? { generatedAt: deps.generatedAt } : {},
+    ...deps.graphId !== undefined ? { graphId: deps.graphId } : {},
+    ...deps.workspaceId !== undefined ? { workspaceId: deps.workspaceId } : {},
+    ...deps.projectDependencyGraph !== undefined ? { projectDependencyGraph: deps.projectDependencyGraph } : {}
+  });
+}
+function formatDependencyGraphDot(model) {
+  const lines = ["digraph RigDependencies {", "  rankdir=LR;"];
+  for (const node of model.nodes) {
+    const color = node.blockerClass === "task-blocked" ? "orange" : node.blockerClass && node.blockerClass !== "not-blocked" ? "red" : "gray";
+    lines.push(`  "${escapeDot(node.taskId)}" [label="${escapeDot(node.title)}", color="${color}"];`);
+  }
+  for (const edge of model.edges) {
+    lines.push(`  "${escapeDot(edge.fromTaskId)}" -> "${escapeDot(edge.toTaskId)}" [label="${edge.type}", color="${edgeColor(edge)}"];`);
+  }
+  lines.push("}");
+  return `${lines.join(`
+`)}
+`;
+}
+function edgeColor(edge) {
+  return edge.type === "blocks" ? "black" : edge.type === "parent-child" ? "blue" : "gray";
+}
+function escapeDot(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+
+// packages/dependency-graph-plugin/src/graph-model/rollups.ts
+import {
+  isOperatorActiveRunStatus,
+  buildTaskReferenceIndex as buildTaskReferenceIndex3,
+  computeTaskDependencyBadges as computeTaskDependencyBadges2,
+  isTaskTerminalStatus,
+  readTaskMetadataStringList as readTaskMetadataStringList3,
+  resolveTaskReference as resolveTaskReference3
+} from "@rig/contracts";
+import { readTaskAssigneeLogins as readTaskAssigneeLogins2 } from "@rig/read-model-plugin";
+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 isObjectRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readIssueType2(task) {
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord2(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 = readTaskMetadataStringList3(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 = buildTaskReferenceIndex3(tasks);
+  const badges = computeTaskDependencyBadges2(tasks);
+  const resolve = (ref) => resolveTaskReference3(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 = readTaskAssigneeLogins2(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 = computeTaskDependencyBadges2(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/dependency-graph-plugin/src/rollups.ts
+import { toTaskSummary as toTaskSummary2 } from "@rig/contracts";
+import { classifyTasks as classifyTasks2 } from "@rig/blocker-classifier-plugin";
+function blockerClassMap(classifications) {
+  return new Map([...classifications.entries()].map(([taskId, classification]) => [taskId, classification.blockerClass]));
+}
+function selectWorkspaceRollups(input) {
+  const tasks = input.tasks.map((task) => toTaskSummary2(task, input.workspaceId !== undefined ? { workspaceId: input.workspaceId } : {}));
+  const runs = input.runs ?? [];
+  const classifications = input.classifications ?? classifyTasks2(input.tasks, runs, input.generatedAt !== undefined ? { generatedAt: input.generatedAt } : {}).byTaskId;
+  return {
+    epics: [...rollupByEpic(tasks, blockerClassMap(classifications))],
+    assignees: [...rollupByAssignee(tasks, runs.map((run) => run.projection))],
+    generatedAt: input.generatedAt ?? new Date().toISOString()
+  };
+}
+async function getWorkspaceRollups(projectRoot, deps) {
+  const [tasks, runs, blockers] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([]),
+    deps.classifyBlockers ? deps.classifyBlockers(projectRoot) : Promise.resolve(null)
+  ]);
+  return selectWorkspaceRollups({
+    tasks,
+    runs,
+    ...blockers?.byTaskId !== undefined ? { classifications: blockers.byTaskId } : {},
+    ...deps.generatedAt !== undefined ? { generatedAt: deps.generatedAt } : {},
+    ...deps.workspaceId !== undefined ? { workspaceId: deps.workspaceId } : {}
+  });
+}
+var getWorkspaceStatus = getWorkspaceRollups;
+// packages/dependency-graph-plugin/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/dependency-graph-plugin/src/taskRanking.ts
+import {
+  computeTaskDependencyBadges as computeTaskDependencyBadges3,
+  isTaskTerminalStatus as isTaskTerminalStatus2,
+  readTaskScope
+} from "@rig/contracts";
+function isObjectRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+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 = isObjectRecord3(task.metadata) ? task.metadata : null;
+  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
+}
+function readTaskCriticality(task) {
+  const metadata = isObjectRecord3(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 = isObjectRecord3(task.metadata) ? task.metadata : null;
+  return readStringList(metadata?.validation);
+}
+function readTaskQueueWeight(task) {
+  const metadata = isObjectRecord3(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 selectNextReadyTaskByPriority(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges3(tasks);
+  const candidates = tasks.filter((task) => !excluded.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true).toSorted((left, right) => {
+    const priorityDelta = priorityValue(left) - priorityValue(right);
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    const createdDelta = (left.createdAt ?? "").localeCompare(right.createdAt ?? "");
+    if (createdDelta !== 0)
+      return createdDelta;
+    return left.id.localeCompare(right.id);
+  });
+  return candidates[0] ?? null;
+}
+function rankReadyTasks(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const activeTaskIds = new Set(options.activeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges3(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 ? !isTaskTerminalStatus2(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/dependency-graph-plugin/src/taskSelection.ts
+import {
+  getTaskForCommand,
+  listTasksForCommand,
+  normalizeTaskId
+} from "@rig/core/task-io";
+var CLOSED_STATUSES = {
+  closed: true,
+  completed: true,
+  complete: true,
+  done: true,
+  cancelled: true,
+  canceled: true,
+  merged: true,
+  resolved: true
+};
+var NOT_READY_STATUSES = {
+  ...CLOSED_STATUSES,
+  blocked: true,
+  in_progress: true,
+  "in-progress": true,
+  running: true,
+  active: true
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readTaskStatus(task) {
+  const value = task.status;
+  return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function isReadyTask(task) {
+  const status = readTaskStatus(task);
+  return status.length === 0 || NOT_READY_STATUSES[status] !== true;
+}
+function asDependencyProjection(task) {
+  const record = task;
+  return {
+    ...record,
+    status: typeof record.status === "string" && record.status.trim() ? record.status : "open",
+    priority: record.priority ?? "P2",
+    metadata: isRecord(record.metadata) ? record.metadata : {}
+  };
+}
+function currentLogin(env = process.env) {
+  for (const key of ["RIG_GITHUB_LOGIN", "GITHUB_ACTOR", "GH_USER", "USER", "USERNAME"]) {
+    const value = env[key]?.trim();
+    if (value)
+      return value;
+  }
+  return;
+}
+function resolveAssignee(value, env = process.env) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  const lowered = trimmed.toLowerCase();
+  if (lowered === "me" || lowered === "@me")
+    return currentLogin(env) ?? "@me";
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+var normalizeAssigneeFilter = resolveAssignee;
+function taskMatchesState(task, state) {
+  if (!state)
+    return true;
+  const closed = CLOSED_STATUSES[readTaskStatus(task)] === true;
+  return state === "closed" ? closed : !closed;
+}
+function taskMatchesSearch(task, search) {
+  const needle = search?.trim().toLowerCase();
+  if (!needle)
+    return true;
+  const title = typeof task.title === "string" ? task.title : "";
+  const body = typeof task.body === "string" ? task.body : "";
+  const description = typeof task.description === "string" ? task.description : "";
+  return `${task.id}
+${title}
+${body}
+${description}`.toLowerCase().includes(needle);
+}
+function collectAssigneeLogins(value) {
+  if (typeof value === "string")
+    return [value];
+  if (Array.isArray(value))
+    return value.flatMap((entry) => collectAssigneeLogins(entry));
+  if (isRecord(value))
+    return [value.login, value.username, value.name, value.id].flatMap((entry) => collectAssigneeLogins(entry));
+  return [];
+}
+function taskAssignees(task) {
+  const raw = isRecord(task.raw) ? task.raw : null;
+  return [
+    task.assignee,
+    task.assignees,
+    task.assignedTo,
+    task.owner,
+    raw?.assignee,
+    raw?.assignees,
+    raw?.assignedTo,
+    raw?.owner
+  ].flatMap((value) => collectAssigneeLogins(value));
+}
+function taskMatchesAssignee(task, assignee) {
+  if (!assignee)
+    return true;
+  const needle = assignee.startsWith("@") ? assignee.slice(1) : assignee;
+  return taskAssignees(task).some((login) => {
+    const normalized = login.startsWith("@") ? login.slice(1) : login;
+    return normalized.localeCompare(needle, undefined, { sensitivity: "accent" }) === 0;
+  });
+}
+function applyFilters(tasks, filters = {}) {
+  const filtered = tasks.filter((task) => taskMatchesAssignee(task, resolveAssignee(filters.assignee))).filter((task) => taskMatchesState(task, filters.state)).filter((task) => taskMatchesSearch(task, filters.search));
+  return filters.limit === undefined ? filtered : filtered.slice(0, filters.limit);
+}
+function selectNextReadyTask(tasks, filters = {}) {
+  const matching = applyFilters(tasks, { ...filters, limit: undefined }).filter(isReadyTask);
+  const selected = selectNextReadyTaskByPriority(matching.map(asDependencyProjection), {
+    filter: (task) => isReadyTask(task)
+  });
+  return selected ?? matching[0] ?? null;
+}
+var selectNextTask = selectNextReadyTask;
+async function resolveStartTask(input) {
+  if (input.next) {
+    const task2 = selectNextReadyTask(await listTasksForCommand(input.projectRoot, { listTasks: input.listTasks }), input.filters ?? {});
+    const taskId2 = normalizeTaskId(task2?.id);
+    if (!task2 || !taskId2)
+      throw new Error("No ready task found.");
+    return { taskId: taskId2, task: task2 };
+  }
+  const taskId = normalizeTaskId(input.taskId ?? undefined);
+  if (!taskId)
+    throw new Error("Missing task id.");
+  const task = await getTaskForCommand(input.projectRoot, taskId, { getTask: input.getTask }).catch(() => null);
+  return { taskId, task };
+}
+
+// packages/dependency-graph-plugin/src/plugin.ts
 var DEPENDENCY_GRAPH_PLUGIN_NAME = "@rig/dependency-graph-plugin";
 var DEPENDENCY_GRAPH_CLI_ID = "dependency-graph.graph";
 var WORKSPACE_STATUS_CLI_ID = "dependency-graph.status";
@@ -10,14 +1042,16 @@ var WORKSPACE_SUMMARY_CLI_ID = "dependency-graph.summary";
 var DEPENDENCY_GRAPH_PANEL_ID = "dependency-graph";
 var EPICS_PANEL_ID = "epics";
 var PEOPLE_PANEL_ID = "people";
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function panelProjectRoot(context) {
-  return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
+  return isRecord2(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
 }
-async function loadDependencyGraphClient() {
-  return await import("@rig/client");
+async function loadDependencyGraphClientIo() {
+  const { listTasks } = await import("@rig/core/task-io");
+  const { listRuns } = await import("@rig/run-worker/runs");
+  return { listRuns, listTasks };
 }
 function toDependencyGraphPanelPayload(model) {
   const layoutByTaskId = new Map(model.layout.nodes.map((node) => [node.taskId, node]));
@@ -46,9 +1080,9 @@ function toDependencyGraphPanelPayload(model) {
     degraded: model.degraded ? "dependency graph projection degraded" : null
   };
 }
-function toWorkspaceRollupsPanelPayload(rollups) {
+function toWorkspaceRollupsPanelPayload(rollups2) {
   return {
-    epics: rollups.epics.map((epic) => ({
+    epics: rollups2.epics.map((epic) => ({
       epicKey: epic.epicKey,
       title: epic.epicKey,
       total: epic.total,
@@ -57,7 +1091,7 @@ function toWorkspaceRollupsPanelPayload(rollups) {
       inFlightCount: epic.inFlightCount,
       humanBlockedCount: epic.humanBlockedCount
     })),
-    people: rollups.assignees.map((assignee) => ({
+    people: rollups2.assignees.map((assignee) => ({
       assignee: assignee.assignee,
       openCount: assignee.openTaskCount,
       inFlightCount: assignee.inFlightRunCount,
@@ -71,7 +1105,7 @@ async function produceDependencyGraphPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { getWorkspaceDependencyGraph, classifyWorkspaceBlockers, listRuns, listTasks } = await loadDependencyGraphClient();
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
   const model = await getWorkspaceDependencyGraph(projectRoot, {
     listTasks,
     listRuns,
@@ -83,13 +1117,13 @@ async function produceWorkspaceRollupsPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { getWorkspaceRollups, classifyWorkspaceBlockers, listRuns, listTasks } = await loadDependencyGraphClient();
-  const rollups = await getWorkspaceRollups(projectRoot, {
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
+  const rollups2 = await getWorkspaceRollups(projectRoot, {
     listTasks,
     listRuns,
     classifyBlockers: (root) => classifyWorkspaceBlockers(root, { listTasks, listRuns })
   });
-  return toWorkspaceRollupsPanelPayload(rollups);
+  return toWorkspaceRollupsPanelPayload(rollups2);
 }
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
@@ -137,7 +1171,7 @@ async function executeGraph(context, args) {
   requireNoExtraArgs(json.rest, "rig graph [--json|--dot]");
   if (dot.value && json.value)
     throw new Error("Pass only one of --json or --dot.");
-  const { getWorkspaceDependencyGraph, classifyWorkspaceBlockers, formatDependencyGraphDot, listRuns, listTasks } = await loadDependencyGraphClient();
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
   const model = await getWorkspaceDependencyGraph(context.projectRoot, {
     listTasks,
     listRuns,
@@ -158,24 +1192,24 @@ async function executeStatus(context, args) {
   const json = takeFlag(args, "--json");
   const epic = takeOption(json.rest, "--epic");
   requireNoExtraArgs(epic.rest, "rig status [--epic <key>] [--json]");
-  const { getWorkspaceRollups, classifyWorkspaceBlockers, listRuns, listTasks } = await loadDependencyGraphClient();
-  const [rollups, blockers, runs] = await Promise.all([
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
+  const [rollups2, blockers, runs] = await Promise.all([
     getWorkspaceRollups(context.projectRoot, { listTasks, listRuns }),
     classifyWorkspaceBlockers(context.projectRoot, { listTasks, listRuns }),
     listRuns(context.projectRoot)
   ]);
-  const filteredEpics = epic.value ? rollups.epics.filter((entry) => entry.epicKey === epic.value) : rollups.epics;
+  const filteredEpics = epic.value ? rollups2.epics.filter((entry) => entry.epicKey === epic.value) : rollups2.epics;
   const details = {
     epic: epic.value ?? null,
     epicRollups: filteredEpics,
     epics: filteredEpics.length,
-    assignees: rollups.assignees.length,
+    assignees: rollups2.assignees.length,
     humanBlockers: blockers.human.length,
     machineBlockers: blockers.machine.length,
     runs: runs.length,
     activeRuns: runs.filter((run) => run.live && !run.stale).length,
     needsAttention: runs.filter((run) => run.status === "needs-attention" || run.pendingApprovals > 0 || run.pendingInputs > 0).length,
-    generatedAt: rollups.generatedAt
+    generatedAt: rollups2.generatedAt
   };
   if (context.outputMode === "text") {
     if (json.value)
@@ -190,9 +1224,9 @@ async function executeSummary(context, args) {
   const json = takeFlag(args, "--json");
   const epicOpt = takeOption(json.rest, "--epic");
   requireNoExtraArgs(epicOpt.rest, "rig summary [--epic <key>] [--json]");
-  const { getWorkspaceRollups, listRuns, listTasks } = await loadDependencyGraphClient();
-  const rollups = await getWorkspaceRollups(context.projectRoot, { listTasks, listRuns });
-  const details = epicOpt.value ? { ...rollups, epics: rollups.epics.filter((epic) => epic.epicKey === epicOpt.value) } : rollups;
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
+  const rollups2 = await getWorkspaceRollups(context.projectRoot, { listTasks, listRuns });
+  const details = epicOpt.value ? { ...rollups2, epics: rollups2.epics.filter((epic) => epic.epicKey === epicOpt.value) } : rollups2;
   if (context.outputMode === "text") {
     if (json.value)
       printJson(details);
@@ -244,36 +1278,51 @@ var dependencyGraphPlugin = definePlugin({
       { id: "workspace.rollups", title: "Workspace rollups", commandId: WORKSPACE_SUMMARY_CLI_ID, panelId: EPICS_PANEL_ID }
     ],
     panels: [
-      { id: DEPENDENCY_GRAPH_PANEL_ID, slot: "capability", title: "Dependency graph", capabilityId: "workspace.dependency-graph" },
-      { id: EPICS_PANEL_ID, slot: "capability", title: "Epics", capabilityId: "workspace.rollups" },
+      { id: DEPENDENCY_GRAPH_PANEL_ID, slot: "capability", title: "Dependency graph", capabilityId: "workspace.dependency-graph", produce: produceDependencyGraphPanel },
+      { id: EPICS_PANEL_ID, slot: "capability", title: "Epics", capabilityId: "workspace.rollups", produce: produceWorkspaceRollupsPanel },
       { id: PEOPLE_PANEL_ID, slot: "capability", title: "People", capabilityId: "workspace.rollups" }
     ],
-    cliCommands: dependencyGraphCliCommands.map(({ run: _run, ...metadata }) => metadata)
-  }
-}, {
-  featureCapabilities: [
-    { id: "workspace.dependency-graph", title: "Workspace dependency graph", commandId: DEPENDENCY_GRAPH_CLI_ID, panelId: DEPENDENCY_GRAPH_PANEL_ID },
-    { id: "workspace.status", title: "Workspace status", commandId: WORKSPACE_STATUS_CLI_ID },
-    { id: "workspace.rollups", title: "Workspace rollups", commandId: WORKSPACE_SUMMARY_CLI_ID, panelId: EPICS_PANEL_ID }
-  ],
-  panels: [
-    { id: DEPENDENCY_GRAPH_PANEL_ID, slot: "capability", title: "Dependency graph", capabilityId: "workspace.dependency-graph", produce: produceDependencyGraphPanel },
-    { id: EPICS_PANEL_ID, slot: "capability", title: "Epics", capabilityId: "workspace.rollups", produce: produceWorkspaceRollupsPanel }
-  ],
-  cliCommands: dependencyGraphCliCommands
+    cliCommands: dependencyGraphCliCommands
+  }
 });
 function createDependencyGraphPlugin() {
   return dependencyGraphPlugin;
 }
 var plugin_default = dependencyGraphPlugin;
 export {
+  taskMatchesState,
+  taskMatchesSearch,
+  taskMatchesAssignee,
+  taskAssignees,
+  selectWorkspaceRollups,
+  selectRankedReadyTasks,
+  selectNextTask,
+  selectNextReadyTaskByPriority,
+  selectNextReadyTask,
+  scoreTask,
+  resolveStartTask,
+  resolveAssignee,
+  readTaskStatus,
+  rankTasks,
+  rankReadyTasks,
+  normalizeAssigneeFilter,
+  isReadyTask,
+  getWorkspaceStatus,
+  getWorkspaceRollups,
+  getWorkspaceDependencyGraph,
+  formatDependencyGraphDot,
   executeSummary,
   executeStatus,
   executeGraph,
   dependencyGraphPlugin,
   dependencyGraphCliCommands,
   plugin_default as default,
+  currentLogin,
   createDependencyGraphPlugin,
+  collectAssigneeLogins,
+  buildWorkspaceDependencyGraph,
+  asDependencyProjection,
+  applyFilters,
   WORKSPACE_SUMMARY_CLI_ID,
   WORKSPACE_STATUS_CLI_ID,
   PEOPLE_PANEL_ID,