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

package/dist/src/index.js

@@ -1,14 +1,439 @@
 // @bun
-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";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import {
+  RUN_READ_MODEL,
+  TASK_IO_SERVICE_CAPABILITY,
+  TASK_SELECTION
+} from "@rig/contracts";
+
+// packages/dependency-graph-plugin/src/analysis/taskGraphPrimitives.ts
+import {
+  OPERATOR_INACTIVE_RUN_STATUSES
+} from "@rig/contracts";
+function isObjectRecord(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 unique(values) {
+  return Array.from(new Set(values));
+}
+function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
+  if (tasksById.has(ref))
+    return ref;
+  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
+}
+function buildTaskReferenceIndex(tasks) {
+  return {
+    tasksById: new Map(tasks.map((task) => [task.id, task])),
+    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
+    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
+      const sourceIssueId = readTaskSourceIssueId(task);
+      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
+    }))
+  };
+}
+function computeTaskBlockingDepths(tasks) {
+  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
+  const memo = new Map;
+  const visit = (taskId, stack) => {
+    const cached = memo.get(taskId);
+    if (cached !== undefined)
+      return cached;
+    if (stack.has(taskId))
+      return 0;
+    const task = tasksById.get(taskId);
+    if (!task)
+      return 0;
+    stack.add(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);
+    return depth;
+  };
+  for (const task of tasks) {
+    visit(task.id, new Set);
+  }
+  return memo;
+}
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (status === null || status === undefined || status === "")
+    return true;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+var TASK_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function metadataOf(task) {
+  return isObjectRecord(task.metadata) ? task.metadata : {};
+}
+function normalizeTaskStatus(status) {
+  const token = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (token === "done")
+    return "completed";
+  if (token === "canceled")
+    return "cancelled";
+  return TASK_STATUSES.has(token) ? token : "unknown";
+}
+function toTaskDependencyProjection(task) {
+  const metadata = metadataOf(task);
+  return {
+    id: String(task.id),
+    title: stringValue(task.title),
+    status: normalizeTaskStatus(task.status),
+    priority: numberOrNull(task.priority),
+    metadata,
+    externalId: stringValue(task.externalId),
+    sourceIssueId: stringValue(task.sourceIssueId),
+    dependencies: stringArray(task.dependencies),
+    parentChildDeps: stringArray(task.parentChildDeps),
+    createdAt: stringValue(task.createdAt) ?? "",
+    updatedAt: stringValue(task.updatedAt) ?? "",
+    role: stringValue(task.role),
+    scope: stringArray(task.scope),
+    validationKeys: stringArray(task.validationKeys),
+    labels: stringArray(task.labels),
+    assignees: task.assignees ?? null,
+    assignedTo: task.assignedTo ?? null
+  };
+}
+function toTaskSummary(task, defaults = {}) {
+  const projection = toTaskDependencyProjection(task);
+  const metadata = metadataOf(task);
+  const createdAt = stringValue(task.createdAt) ?? "1970-01-01T00:00:00.000Z";
+  const updatedAt = stringValue(task.updatedAt) ?? createdAt;
+  return {
+    id: projection.id,
+    workspaceId: stringValue(task.workspaceId) ?? defaults.workspaceId ?? "workspace",
+    graphId: stringValue(task.graphId) ?? defaults.graphId ?? null,
+    externalId: projection.externalId,
+    title: projection.title ?? projection.id,
+    description: stringValue(task.description) ?? stringValue(task.body) ?? "",
+    status: projection.status,
+    priority: numberOrNull(task.priority),
+    role: projection.role,
+    scope: [...projection.scope ?? []],
+    validationKeys: [...projection.validationKeys ?? []],
+    ...projection.sourceIssueId ? { sourceIssueId: projection.sourceIssueId } : {},
+    dependencies: [...projection.dependencies ?? []],
+    parentChildDeps: [...projection.parentChildDeps ?? []],
+    metadata,
+    createdAt,
+    updatedAt
+  };
+}
+function taskPriorityValue(task) {
+  return typeof task.priority === "number" && Number.isFinite(task.priority) ? task.priority : Number.MAX_SAFE_INTEGER;
+}
+function selectNextReadyTaskByPriority(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges(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 = taskPriorityValue(left) - taskPriorityValue(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 normalizeLogin(value) {
+  return value.trim().replace(/^@+/, "").toLowerCase();
+}
+function assigneeLoginsFromValue(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [normalizeLogin(entry)];
+    if (isObjectRecord(entry) && typeof entry.login === "string" && entry.login.trim()) {
+      return [normalizeLogin(entry.login)];
+    }
+    return [];
+  });
+}
+function readTaskAssigneeLogins(task) {
+  const taskRecord = task;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord(metadata?.raw) ? metadata.raw : null;
+  return Array.from(new Set([
+    ...assigneeLoginsFromValue(taskRecord.assignees),
+    ...assigneeLoginsFromValue(metadata?.assignees),
+    ...assigneeLoginsFromValue(raw?.assignees)
+  ]));
+}
+function latestRunByTaskId(runs) {
+  const byTask = new Map;
+  const stamp = (run) => Date.parse(run.updatedAt ?? run.startedAt ?? "") || 0;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    const current = byTask.get(run.taskId);
+    if (!current || stamp(run) >= stamp(current))
+      byTask.set(run.taskId, run);
+  }
+  return byTask;
+}
+function normalizeRunStatusToken(status) {
+  return String(status ?? "").trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function isOperatorActiveRunStatus(status) {
+  const normalized = normalizeRunStatusToken(status);
+  if (!normalized)
+    return false;
+  return !OPERATOR_INACTIVE_RUN_STATUSES.has(normalized);
+}
 
-// 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/analysis/blockers.ts
+var HUMAN_BLOCKERS = new Set(["human-decision", "human-approval", "external-input"]);
+function labelsFor(task) {
+  return readTaskMetadataStringList(task, "labels").map((label) => label.toLowerCase());
+}
+function configuredTier(task, labels) {
+  const metadata = task.metadata && typeof task.metadata === "object" && !Array.isArray(task.metadata) ? task.metadata : {};
+  const tier = metadata.riskTier ?? metadata.actionRiskTier;
+  if (tier === "t1-read" || tier === "t2-reversible" || tier === "t3-external" || tier === "t4-irreversible")
+    return tier;
+  if (labels.some((label) => /prod|deploy|migration|billing|delete|irreversible/.test(label)))
+    return "t4-irreversible";
+  if (labels.some((label) => /customer|vendor|external|secret|credential|approval|decision/.test(label)))
+    return "t3-external";
+  const scopes = task.scope ?? [];
+  if (scopes.some((scope) => /docs|readme|test|spec/.test(scope.toLowerCase())))
+    return "t1-read";
+  return "t2-reversible";
+}
+function tierOf(task, labels = []) {
+  const projection = "metadata" in task && "id" in task && typeof task.id === "string" ? toTaskDependencyProjection(task) : task;
+  return configuredTier(projection, labels.length > 0 ? labels : labelsFor(projection)) ?? "t2-reversible";
+}
+function baseClassification(task, blockerClass, source, rationale, labels) {
+  return {
+    taskId: task.id,
+    blockerClass,
+    actionRiskTier: tierOf(task, labels),
+    rationale,
+    source,
+    autoApplied: source === "llm"
+  };
+}
+function normalizeRunStatus(status) {
+  if (status === "waiting-approval" || status === "waiting-user-input" || status === "needs-attention" || status === "completed" || status === "failed" || status === "stopped" || status === "running")
+    return status;
+  return null;
+}
+function isHumanBlockerClass(blockerClass) {
+  return HUMAN_BLOCKERS.has(blockerClass);
+}
+function classifyBlocker(input) {
+  const labels = input.labels ?? labelsFor(input.task);
+  const runStatus = normalizeRunStatus(input.run?.status);
+  if (runStatus === "waiting-approval")
+    return baseClassification(input.task, "human-approval", "status", "run awaiting approval", labels);
+  if (runStatus === "waiting-user-input")
+    return baseClassification(input.task, "external-input", "status", "run awaiting user input", labels);
+  if (input.task.status !== "blocked")
+    return baseClassification(input.task, "not-blocked", "elimination", "task is not blocked", labels);
+  const incomplete = (input.badges.get(input.task.id)?.blockedBy ?? []).filter((dependencyId) => {
+    const dependency = input.tasksById.get(dependencyId);
+    return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+  });
+  if (incomplete.length > 0)
+    return baseClassification(input.task, "task-blocked", "elimination", `blocked by ${incomplete.length} incomplete task(s)`, labels);
+  if (labels.includes("needs-decision"))
+    return baseClassification(input.task, "human-decision", "label", "needs-decision label", labels);
+  if (labels.some((label) => /^waiting-on-/.test(label)))
+    return baseClassification(input.task, "external-input", "label", "waiting-on-* label", labels);
+  if (input.config?.llm)
+    return baseClassification(input.task, "human-decision", "llm", "LLM residue classifier marked this as human-gated", labels);
+  return baseClassification(input.task, "human-decision", "elimination", "blocked, all task dependencies terminal; non-task gate remains", labels);
+}
+function classifyTasks(tasks, runs = [], options = {}) {
+  const projected = tasks.map(toTaskDependencyProjection);
+  const badges = computeTaskDependencyBadges(projected);
+  const tasksById = new Map(projected.map((task) => [task.id, task]));
+  const runByTask = latestRunByTaskId(runs);
+  const classifier = options.classifier ?? classifyBlocker;
+  const classifications = projected.map((task) => classifier({ task, badges, tasksById, run: runByTask.get(task.id) ?? null, labels: labelsFor(task) })).filter((classification) => options.humanOnly !== true || isHumanBlockerClass(classification.blockerClass));
+  return {
+    classifications,
+    byTaskId: new Map(classifications.map((classification) => [classification.taskId, classification])),
+    human: classifications.filter((classification) => isHumanBlockerClass(classification.blockerClass)),
+    machine: classifications.filter((classification) => !isHumanBlockerClass(classification.blockerClass)),
+    generatedAt: options.generatedAt ?? new Date().toISOString()
+  };
+}
+async function classifyWorkspaceBlockers(projectRoot, deps) {
+  const [tasks, runs] = await Promise.all([
+    deps.listTasks(projectRoot),
+    deps.listRuns ? deps.listRuns(projectRoot) : Promise.resolve([])
+  ]);
+  return classifyTasks(tasks, runs, deps);
+}
 
-// packages/dependency-graph-plugin/src/graph-model/taskGraphCodes.ts
+// packages/dependency-graph-plugin/src/analysis/taskGraphCodes.ts
 var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
 function extractTaskCode(title) {
   const match = title.match(TASK_CODE_RE);
@@ -29,17 +454,7 @@ 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";
+// packages/dependency-graph-plugin/src/analysis/taskGraphLayout.ts
 var CARD_WIDTH = 200;
 var CARD_HEIGHT = 110;
 var CELL_V_PAD = 12;
@@ -58,14 +473,14 @@ var PALETTE = [
   { bg: "#132c35", border: "#1783a6", edge: "#53c4e5" },
   { bg: "#26310f", border: "#6d9a19", edge: "#a7da42" }
 ];
-function isObjectRecord(value) {
+function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readIssueType(task) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
   if (typeof metadata?.issueType === "string")
     return metadata.issueType;
-  const raw = isObjectRecord(metadata?.raw) ? metadata.raw : null;
+  const raw = isObjectRecord2(metadata?.raw) ? metadata.raw : null;
   return typeof raw?.issueType === "string" ? raw.issueType : null;
 }
 function isGraphTask(task) {
@@ -164,7 +579,7 @@ function computeDepths(ids, edges) {
   }
   return memo;
 }
-function buildTaskGraphLayout(snapshot, tasks, options) {
+function buildTaskGraphLayout(tasks, options) {
   const showParentChild = options?.showParentChild ?? false;
   const graphTasks = tasks.filter(isGraphTask);
   if (graphTasks.length === 0) {
@@ -295,7 +710,6 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
     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) {
@@ -304,13 +718,6 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
       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,
@@ -328,12 +735,12 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
           strippedTitle: stripTaskCode(task.title),
           depsIn: depsIn.get(task.id) ?? 0,
           depsOut: depsOut.get(task.id) ?? 0,
-          runCount: runs.length,
-          hasApprovals,
-          hasPendingUserInput,
-          hasRejectedReview,
-          hasFailedValidations,
-          artifactCount
+          runCount: 0,
+          hasApprovals: false,
+          hasPendingUserInput: false,
+          hasRejectedReview: false,
+          hasFailedValidations: false,
+          artifactCount: 0
         });
       }
     }
@@ -349,8 +756,37 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
   };
 }
 
-// packages/dependency-graph-plugin/src/graph-model/dependencyGraph.ts
-import { readTaskAssigneeLogins } from "@rig/read-model-plugin";
+// packages/dependency-graph-plugin/src/analysis/rigSelectors.ts
+function isObjectRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeLogin2(value) {
+  return value.trim().replace(/^@+/, "").toLowerCase();
+}
+function assigneeLoginsFromValue2(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string" && entry.trim())
+      return [normalizeLogin2(entry)];
+    if (isObjectRecord3(entry) && typeof entry.login === "string" && entry.login.trim()) {
+      return [normalizeLogin2(entry.login)];
+    }
+    return [];
+  });
+}
+function readTaskAssigneeLogins2(task) {
+  const taskRecord = task;
+  const metadata = isObjectRecord3(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord3(metadata?.raw) ? metadata.raw : null;
+  return Array.from(new Set([
+    ...assigneeLoginsFromValue2(taskRecord.assignees),
+    ...assigneeLoginsFromValue2(metadata?.assignees),
+    ...assigneeLoginsFromValue2(raw?.assignees)
+  ]));
+}
+
+// packages/dependency-graph-plugin/src/analysis/dependencyGraph.ts
 function uniqueSorted(values) {
   return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
 }
@@ -432,19 +868,19 @@ function detectBlockingCycles(tasks, edges) {
 }
 function buildDependencyGraphModel(tasks, options = {}) {
   const badges = computeTaskDependencyBadges(tasks);
-  const index = buildTaskReferenceIndex2(tasks);
+  const index = buildTaskReferenceIndex(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);
+    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 readTaskMetadataStringList2(task, "parentChildDeps")) {
-      const parentId = resolveTaskReference2(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+    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
@@ -454,7 +890,7 @@ function buildDependencyGraphModel(tasks, options = {}) {
   const dedupedEdges = dedupeEdges(edges);
   const nodes = tasks.map((task) => {
     const summary = badges.get(task.id);
-    const assignees = readTaskAssigneeLogins(task);
+    const assignees = readTaskAssigneeLogins2(task);
     const groupKey = extractTaskGroupKey(task.title);
     return {
       taskId: String(task.id),
@@ -479,7 +915,7 @@ function buildDependencyGraphModel(tasks, options = {}) {
     graphId: options.graphId ?? deriveGraphId(tasks),
     nodes,
     edges: dedupedEdges,
-    layout: buildTaskGraphLayout(options.snapshot ?? null, tasks, { showParentChild: options.showParentChild ?? true }),
+    layout: buildTaskGraphLayout(tasks, { showParentChild: options.showParentChild ?? true }),
     cycles: detectBlockingCycles(tasks, dedupedEdges),
     unresolvedRefs: uniqueSorted(unresolvedRefs),
     degraded: false,
@@ -487,9 +923,7 @@ function buildDependencyGraphModel(tasks, options = {}) {
   };
 }
 
-// packages/dependency-graph-plugin/src/graph.ts
-import { toTaskSummary } from "@rig/contracts";
-import { classifyTasks } from "@rig/blocker-classifier-plugin";
+// packages/dependency-graph-plugin/src/analysis/graph.ts
 function overlayLayoutRunState(model, runs) {
   if (runs.length === 0)
     return model.layout;
@@ -572,16 +1006,7 @@ 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";
+// packages/dependency-graph-plugin/src/analysis/rollupModel.ts
 var UNASSIGNED_EPIC = "(unassigned-epic)";
 var UNASSIGNED_ASSIGNEE = "(unassigned)";
 var HUMAN_BLOCKER_CLASSES = {
@@ -590,12 +1015,12 @@ var HUMAN_BLOCKER_CLASSES = {
   "external-input": true,
   unknown: true
 };
-function isObjectRecord2(value) {
+function isObjectRecord4(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 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;
 }
@@ -614,7 +1039,7 @@ function isInFlightTaskStatus(status) {
   }
 }
 function epicKeyForTask(task, tasksById, resolve) {
-  const parentRef = readTaskMetadataStringList3(task, "parentChildDeps")[0];
+  const parentRef = readTaskMetadataStringList(task, "parentChildDeps")[0];
   const parentId = parentRef ? resolve(parentRef) : null;
   const parent = parentId ? tasksById.get(parentId) : null;
   if (parent)
@@ -622,9 +1047,9 @@ function epicKeyForTask(task, tasksById, resolve) {
   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 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))
@@ -667,7 +1092,7 @@ function assigneesForTask(task) {
 }
 function rollupByAssignee(tasks, runs) {
   const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
-  const badges = computeTaskDependencyBadges2(tasks);
+  const badges = computeTaskDependencyBadges(tasks);
   const buckets = new Map;
   const ensureBucket = (assignee) => {
     const existing = buckets.get(assignee);
@@ -714,16 +1139,14 @@ function rollupByAssignee(tasks, runs) {
   })).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";
+// packages/dependency-graph-plugin/src/analysis/rollups.ts
 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 tasks = input.tasks.map((task) => toTaskSummary(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;
+  const classifications = input.classifications ?? classifyTasks(input.tasks, runs, input.generatedAt !== undefined ? { generatedAt: input.generatedAt } : {}).byTaskId;
   return {
     epics: [...rollupByEpic(tasks, blockerClassMap(classifications))],
     assignees: [...rollupByAssignee(tasks, runs.map((run) => run.projection))],
@@ -744,165 +1167,31 @@ async function getWorkspaceRollups(projectRoot, deps) {
     ...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) {
+
+// 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";
+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";
+var TaskSelectionCap = defineCapability(TASK_SELECTION);
+var RunReadModelCap = defineCapability(RUN_READ_MODEL);
+function isRecord(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 panelProjectRoot(context) {
+  return isRecord(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
 }
-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;
+async function loadDependencyGraphClientIo(projectRoot) {
+  const [taskIo, runReadModel] = await Promise.all([
+    requireCapabilityForRoot(projectRoot, defineCapability(TASK_IO_SERVICE_CAPABILITY), "No task-sources plugin provides task IO for this project root."),
+    requireCapabilityForRoot(projectRoot, RunReadModelCap, "No run-worker plugin provides run read-model for this project root.")
+  ]);
+  return { listRuns: (root) => runReadModel.listRuns({ projectRoot: root }), listTasks: taskIo.listTasks };
 }
-// packages/dependency-graph-plugin/src/taskSelection.ts
-import {
-  getTaskForCommand,
-  listTasksForCommand,
-  normalizeTaskId
-} from "@rig/core/task-io";
-var CLOSED_STATUSES = {
+var CLOSED_TASK_STATUSES = {
   closed: true,
   completed: true,
   complete: true,
@@ -912,146 +1201,53 @@ var CLOSED_STATUSES = {
   merged: true,
   resolved: true
 };
-var NOT_READY_STATUSES = {
-  ...CLOSED_STATUSES,
+var NOT_READY_TASK_STATUSES = {
+  ...CLOSED_TASK_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 taskStatus(task) {
+  return typeof task.status === "string" ? task.status.trim().toLowerCase() : "";
 }
-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 taskIsReady(task) {
+  const status = taskStatus(task);
+  return status.length === 0 || NOT_READY_TASK_STATUSES[status] !== true;
 }
-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;
+function taskMatchesSelectionFilters(task, filters = {}) {
+  if (filters.state) {
+    const closed = CLOSED_TASK_STATUSES[taskStatus(task)] === true;
+    if (filters.state === "closed" ? !closed : closed)
+      return false;
   }
-  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}
+  const search = filters.search?.trim().toLowerCase();
+  if (search) {
+    const title = typeof task.title === "string" ? task.title : "";
+    const body = typeof task.body === "string" ? task.body : "";
+    const description = typeof task.description === "string" ? task.description : "";
+    if (!`${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 };
+${description}`.toLowerCase().includes(search))
+      return false;
   }
-  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";
-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 isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function panelProjectRoot(context) {
-  return isRecord2(context) && typeof context.projectRoot === "string" && context.projectRoot.length > 0 ? context.projectRoot : null;
-}
-async function loadDependencyGraphClientIo() {
-  const { listTasks } = await import("@rig/core/task-io");
-  const { listRuns } = await import("@rig/run-worker/runs");
-  return { listRuns, listTasks };
+  const assignee = filters.assignee?.trim().replace(/^@+/, "").toLowerCase();
+  if (assignee && !readTaskAssigneeLogins(toTaskDependencyProjection(task)).some((login) => login.replace(/^@+/, "").toLowerCase() === assignee))
+    return false;
+  return true;
+}
+function selectReadyTaskSummary(tasks, filters = {}) {
+  const candidates = tasks.filter((task) => taskMatchesSelectionFilters(task, filters)).filter(taskIsReady).map((task) => toTaskSummary(task));
+  const badges = computeTaskDependencyBadges(candidates);
+  const ready = candidates.filter((task) => badges.get(task.id)?.ready === true);
+  const selected = selectNextReadyTaskByPriority(candidates);
+  return { selected: selected ?? candidates[0] ?? null, ready };
+}
+async function selectNextReadyTaskForProject(input) {
+  const { listTasks } = await loadDependencyGraphClientIo(input.projectRoot);
+  return selectReadyTaskSummary(await listTasks(input.projectRoot), input.filters);
 }
 function toDependencyGraphPanelPayload(model) {
   const layoutByTaskId = new Map(model.layout.nodes.map((node) => [node.taskId, node]));
@@ -1080,9 +1276,9 @@ function toDependencyGraphPanelPayload(model) {
     degraded: model.degraded ? "dependency graph projection degraded" : null
   };
 }
-function toWorkspaceRollupsPanelPayload(rollups2) {
+function toWorkspaceRollupsPanelPayload(rollups) {
   return {
-    epics: rollups2.epics.map((epic) => ({
+    epics: rollups.epics.map((epic) => ({
       epicKey: epic.epicKey,
       title: epic.epicKey,
       total: epic.total,
@@ -1091,7 +1287,7 @@ function toWorkspaceRollupsPanelPayload(rollups2) {
       inFlightCount: epic.inFlightCount,
       humanBlockedCount: epic.humanBlockedCount
     })),
-    people: rollups2.assignees.map((assignee) => ({
+    people: rollups.assignees.map((assignee) => ({
       assignee: assignee.assignee,
       openCount: assignee.openTaskCount,
       inFlightCount: assignee.inFlightRunCount,
@@ -1105,7 +1301,7 @@ async function produceDependencyGraphPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo(projectRoot);
   const model = await getWorkspaceDependencyGraph(projectRoot, {
     listTasks,
     listRuns,
@@ -1117,13 +1313,13 @@ async function produceWorkspaceRollupsPanel(context) {
   const projectRoot = panelProjectRoot(context);
   if (!projectRoot)
     return;
-  const { listRuns, listTasks } = await loadDependencyGraphClientIo();
-  const rollups2 = await getWorkspaceRollups(projectRoot, {
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo(projectRoot);
+  const rollups = await getWorkspaceRollups(projectRoot, {
     listTasks,
     listRuns,
     classifyBlockers: (root) => classifyWorkspaceBlockers(root, { listTasks, listRuns })
   });
-  return toWorkspaceRollupsPanelPayload(rollups2);
+  return toWorkspaceRollupsPanelPayload(rollups);
 }
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
@@ -1171,7 +1367,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 { listRuns, listTasks } = await loadDependencyGraphClientIo();
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo(context.projectRoot);
   const model = await getWorkspaceDependencyGraph(context.projectRoot, {
     listTasks,
     listRuns,
@@ -1192,24 +1388,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 { listRuns, listTasks } = await loadDependencyGraphClientIo();
-  const [rollups2, blockers, runs] = await Promise.all([
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo(context.projectRoot);
+  const [rollups, blockers, runs] = await Promise.all([
     getWorkspaceRollups(context.projectRoot, { listTasks, listRuns }),
     classifyWorkspaceBlockers(context.projectRoot, { listTasks, listRuns }),
     listRuns(context.projectRoot)
   ]);
-  const filteredEpics = epic.value ? rollups2.epics.filter((entry) => entry.epicKey === epic.value) : rollups2.epics;
+  const filteredEpics = epic.value ? rollups.epics.filter((entry) => entry.epicKey === epic.value) : rollups.epics;
   const details = {
     epic: epic.value ?? null,
     epicRollups: filteredEpics,
     epics: filteredEpics.length,
-    assignees: rollups2.assignees.length,
+    assignees: rollups.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: rollups2.generatedAt
+    generatedAt: rollups.generatedAt
   };
   if (context.outputMode === "text") {
     if (json.value)
@@ -1224,9 +1420,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 { 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;
+  const { listRuns, listTasks } = await loadDependencyGraphClientIo(context.projectRoot);
+  const rollups = await getWorkspaceRollups(context.projectRoot, { listTasks, listRuns });
+  const details = epicOpt.value ? { ...rollups, epics: rollups.epics.filter((epic) => epic.epicKey === epicOpt.value) } : rollups;
   if (context.outputMode === "text") {
     if (json.value)
       printJson(details);
@@ -1275,7 +1471,8 @@ var dependencyGraphPlugin = definePlugin({
     capabilities: [
       { 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 }
+      { id: "workspace.rollups", title: "Workspace rollups", commandId: WORKSPACE_SUMMARY_CLI_ID, panelId: EPICS_PANEL_ID },
+      TaskSelectionCap.provide({ selectNextReadyTask: selectNextReadyTaskForProject }, { title: "Task selection", description: "Select the next ready task from the configured task source." })
     ],
     panels: [
       { id: DEPENDENCY_GRAPH_PANEL_ID, slot: "capability", title: "Dependency graph", capabilityId: "workspace.dependency-graph", produce: produceDependencyGraphPanel },
@@ -1289,38 +1486,12 @@ function createDependencyGraphPlugin() {
   return 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,
-  currentLogin,
   createDependencyGraphPlugin,
-  collectAssigneeLogins,
-  buildWorkspaceDependencyGraph,
-  asDependencyProjection,
-  applyFilters,
   WORKSPACE_SUMMARY_CLI_ID,
   WORKSPACE_STATUS_CLI_ID,
   PEOPLE_PANEL_ID,