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

package/dist/src/rollups.d.ts

@@ -0,0 +1,20 @@
+import type { TaskLike } from "@rig/core/task-io";
+import type { BlockerClassification, RunRecord, WorkspaceRollups } from "@rig/contracts";
+import { type WorkspaceBlockers } from "@rig/blocker-classifier-plugin";
+export interface SelectWorkspaceRollupsInput {
+    readonly tasks: readonly TaskLike[];
+    readonly runs?: readonly RunRecord[];
+    readonly classifications?: ReadonlyMap<string, BlockerClassification>;
+    readonly generatedAt?: string;
+    readonly workspaceId?: string;
+}
+export interface GetWorkspaceRollupsDeps {
+    readonly listTasks: (projectRoot: string) => Promise<readonly TaskLike[]>;
+    readonly listRuns?: (projectRoot: string) => Promise<readonly RunRecord[]>;
+    readonly classifyBlockers?: (projectRoot: string) => Promise<WorkspaceBlockers>;
+    readonly generatedAt?: string;
+    readonly workspaceId?: string;
+}
+export declare function selectWorkspaceRollups(input: SelectWorkspaceRollupsInput): WorkspaceRollups;
+export declare function getWorkspaceRollups(projectRoot: string, deps: GetWorkspaceRollupsDeps): Promise<WorkspaceRollups>;
+export declare const getWorkspaceStatus: typeof getWorkspaceRollups;

package/dist/src/rollups.js

@@ -0,0 +1,199 @@
+// @bun
+// packages/dependency-graph-plugin/src/graph-model/rollups.ts
+import {
+  isOperatorActiveRunStatus,
+  buildTaskReferenceIndex,
+  computeTaskDependencyBadges,
+  isTaskTerminalStatus,
+  readTaskMetadataStringList,
+  resolveTaskReference
+} from "@rig/contracts";
+import { readTaskAssigneeLogins } from "@rig/read-model-plugin";
+
+// 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;
+}
+
+// packages/dependency-graph-plugin/src/graph-model/rollups.ts
+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 isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readIssueType(task) {
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord(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 readIssueType(task) === "epic";
+}
+function isInFlightTaskStatus(status) {
+  switch (status) {
+    case "queued":
+    case "running":
+    case "in_progress":
+    case "under_review":
+      return true;
+    default:
+      return false;
+  }
+}
+function epicKeyForTask(task, tasksById, resolve) {
+  const parentRef = readTaskMetadataStringList(task, "parentChildDeps")[0];
+  const parentId = parentRef ? resolve(parentRef) : null;
+  const parent = parentId ? tasksById.get(parentId) : null;
+  if (parent)
+    return extractTaskGroupKey(parent.title) ?? parent.title ?? parent.id;
+  return extractTaskGroupKey(task.title) ?? UNASSIGNED_EPIC;
+}
+function rollupByEpic(tasks, classifications = new Map) {
+  const index = buildTaskReferenceIndex(tasks);
+  const badges = computeTaskDependencyBadges(tasks);
+  const resolve = (ref) => resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+  const buckets = new Map;
+  for (const task of tasks) {
+    if (isEpicTask(task))
+      continue;
+    const epicKey = epicKeyForTask(task, index.tasksById, resolve);
+    const current = buckets.get(epicKey) ?? {
+      total: 0,
+      completed: 0,
+      blockedCount: 0,
+      humanBlockedCount: 0,
+      inFlightCount: 0,
+      byStatus: {}
+    };
+    current.total += 1;
+    if (isTaskTerminalStatus(task.status))
+      current.completed += 1;
+    if (badges.get(task.id)?.blocked === true)
+      current.blockedCount += 1;
+    if (isInFlightTaskStatus(task.status))
+      current.inFlightCount += 1;
+    const classification = classifications.get(task.id);
+    if (classification && HUMAN_BLOCKER_CLASSES[classification])
+      current.humanBlockedCount += 1;
+    current.byStatus[task.status] = (current.byStatus[task.status] ?? 0) + 1;
+    buckets.set(epicKey, current);
+  }
+  return [...buckets.entries()].map(([epicKey, bucket]) => ({
+    epicKey,
+    total: bucket.total,
+    percentComplete: bucket.total === 0 ? 0 : Math.round(100 * bucket.completed / bucket.total),
+    blockedCount: bucket.blockedCount,
+    humanBlockedCount: bucket.humanBlockedCount,
+    inFlightCount: bucket.inFlightCount,
+    byStatus: Object.fromEntries(Object.entries(bucket.byStatus).sort(([left], [right]) => left.localeCompare(right)))
+  })).toSorted((left, right) => left.epicKey.localeCompare(right.epicKey));
+}
+function assigneesForTask(task) {
+  const assignees = readTaskAssigneeLogins(task);
+  return assignees.length > 0 ? assignees : [UNASSIGNED_ASSIGNEE];
+}
+function rollupByAssignee(tasks, runs) {
+  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
+  const badges = computeTaskDependencyBadges(tasks);
+  const buckets = new Map;
+  const ensureBucket = (assignee) => {
+    const existing = buckets.get(assignee);
+    if (existing)
+      return existing;
+    const created = { openTaskCount: 0, inFlightRunIds: new Set, prsAwaitingReview: 0, blockers: new Set };
+    buckets.set(assignee, created);
+    return created;
+  };
+  for (const task of tasks) {
+    if (isEpicTask(task))
+      continue;
+    for (const assignee of assigneesForTask(task)) {
+      const bucket = ensureBucket(assignee);
+      if (!isTaskTerminalStatus(task.status))
+        bucket.openTaskCount += 1;
+      if (badges.get(task.id)?.blocked === true)
+        bucket.blockers.add(task.id);
+      if (task.status === "under_review")
+        bucket.prsAwaitingReview += 1;
+    }
+  }
+  for (const run of runs) {
+    const taskId = run.record.taskId;
+    const task = taskId ? tasksById.get(taskId) : null;
+    if (!task)
+      continue;
+    if (isEpicTask(task))
+      continue;
+    for (const assignee of assigneesForTask(task)) {
+      const bucket = ensureBucket(assignee);
+      if (run.status && isOperatorActiveRunStatus(run.status))
+        bucket.inFlightRunIds.add(run.record.runId ?? `${String(task.id)}:${run.lastSeq}`);
+      if (run.status === "reviewing" && run.record.prUrl)
+        bucket.prsAwaitingReview += 1;
+    }
+  }
+  return [...buckets.entries()].map(([assignee, bucket]) => ({
+    assignee,
+    openTaskCount: bucket.openTaskCount,
+    inFlightRunCount: bucket.inFlightRunIds.size,
+    prsAwaitingReview: bucket.prsAwaitingReview,
+    blockers: [...bucket.blockers].toSorted((left, right) => String(left).localeCompare(String(right)))
+  })).toSorted((left, right) => left.assignee.localeCompare(right.assignee));
+}
+
+// packages/dependency-graph-plugin/src/rollups.ts
+import { toTaskSummary } from "@rig/contracts";
+import { classifyTasks } 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) => toTaskSummary(task, input.workspaceId !== undefined ? { workspaceId: input.workspaceId } : {}));
+  const runs = input.runs ?? [];
+  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))],
+    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;
+export {
+  selectWorkspaceRollups,
+  getWorkspaceStatus,
+  getWorkspaceRollups
+};

package/dist/src/taskRanking.d.ts

@@ -0,0 +1,24 @@
+import { type TaskDependencyProjection } from "@rig/contracts";
+export declare function selectNextReadyTaskByPriority<T extends TaskDependencyProjection>(tasks: readonly T[], options?: {
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly filter?: (task: T) => boolean;
+}): T | null;
+export type ReadyTaskSelectionMode = "all-ready" | "blocking-only" | "max-unblock";
+export interface RankedReadyTask<T extends TaskDependencyProjection> {
+    readonly task: T;
+    readonly score: number;
+    readonly priority: number;
+    readonly unblockCount: number;
+    readonly scope: readonly string[];
+}
+export interface RankedReadyTaskOptions<T extends TaskDependencyProjection> {
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly activeTaskIds?: Iterable<string>;
+    readonly filter?: (task: T) => boolean;
+    readonly selection?: ReadyTaskSelectionMode;
+    readonly requireDisjointScopes?: boolean;
+    readonly disjointWithScopes?: Iterable<string>;
+    readonly limit?: number;
+}
+export declare function rankReadyTasks<T extends TaskDependencyProjection>(tasks: readonly T[], options?: Omit<RankedReadyTaskOptions<T>, "limit" | "requireDisjointScopes" | "disjointWithScopes">): readonly RankedReadyTask<T>[];
+export declare function selectRankedReadyTasks<T extends TaskDependencyProjection>(tasks: readonly T[], options?: RankedReadyTaskOptions<T>): readonly T[];

package/dist/src/taskRanking.js

@@ -0,0 +1,160 @@
+// @bun
+// packages/dependency-graph-plugin/src/taskRanking.ts
+import {
+  computeTaskDependencyBadges,
+  isTaskTerminalStatus,
+  readTaskScope
+} from "@rig/contracts";
+
+// 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
+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 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 = isObjectRecord(task.metadata) ? task.metadata : null;
+  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
+}
+function readTaskCriticality(task) {
+  const metadata = isObjectRecord(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 = isObjectRecord(task.metadata) ? task.metadata : null;
+  return readStringList(metadata?.validation);
+}
+function readTaskQueueWeight(task) {
+  const metadata = isObjectRecord(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 = 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 = 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 = computeTaskDependencyBadges(tasks);
+  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
+  const openBlockCount = (task) => (badges.get(task.id)?.blocks ?? []).filter((blockedTaskId) => {
+    const blockedTask = tasksById.get(blockedTaskId);
+    return blockedTask ? !isTaskTerminalStatus(blockedTask.status) : false;
+  }).length;
+  const readyTasks = tasks.filter((task) => !excluded.has(task.id)).filter((task) => !activeTaskIds.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true);
+  const maxUnblockCount = Math.max(0, ...readyTasks.map(openBlockCount));
+  const selectedByMode = readyTasks.filter((task) => {
+    const unblockCount = openBlockCount(task);
+    if (options.selection === "blocking-only")
+      return unblockCount > 0;
+    if (options.selection === "max-unblock")
+      return maxUnblockCount > 0 && unblockCount === maxUnblockCount;
+    return true;
+  });
+  return rankTasks(selectedByMode, (task) => scoreInputForTask(task, openBlockCount(task)), (task) => task.id).map((entry) => ({
+    task: entry.task,
+    score: entry.score,
+    priority: entry.priority,
+    unblockCount: entry.unblockCount,
+    scope: readTaskScope(entry.task)
+  }));
+}
+function selectRankedReadyTasks(tasks, options = {}) {
+  const ranked = rankReadyTasks(tasks, options);
+  if (options.requireDisjointScopes !== true && !options.disjointWithScopes) {
+    return ranked.slice(0, options.limit).map((entry) => entry.task);
+  }
+  const occupiedScopes = new Set(options.disjointWithScopes ?? []);
+  const selected = [];
+  for (const entry of ranked) {
+    if (entry.scope.some((scope) => occupiedScopes.has(scope)))
+      continue;
+    selected.push(entry.task);
+    for (const scope of entry.scope)
+      occupiedScopes.add(scope);
+    if (options.limit !== undefined && selected.length >= options.limit)
+      break;
+  }
+  return selected;
+}
+export {
+  selectRankedReadyTasks,
+  selectNextReadyTaskByPriority,
+  rankReadyTasks
+};

package/dist/src/taskScore.d.ts

@@ -0,0 +1,17 @@
+export type TaskCriticality = "core" | "high" | "normal" | string;
+export interface TaskScoreInput {
+    readonly priority?: number | null;
+    readonly unblockCount?: number | null;
+    readonly role?: string | null;
+    readonly criticality?: TaskCriticality | null;
+    readonly validation?: readonly string[] | null;
+    readonly queueWeight?: number | null;
+}
+export interface RankedTask<T> {
+    readonly task: T;
+    readonly score: number;
+    readonly priority: number;
+    readonly unblockCount: number;
+}
+export declare function scoreTask(input: TaskScoreInput): number;
+export declare function rankTasks<T>(tasks: readonly T[], scoreInput: (task: T) => TaskScoreInput, idOf: (task: T) => string): readonly RankedTask<T>[];

package/dist/src/taskScore.js

@@ -0,0 +1,49 @@
+// @bun
+// 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));
+  });
+}
+export {
+  scoreTask,
+  rankTasks
+};

package/dist/src/taskSelection.d.ts

@@ -0,0 +1,33 @@
+import { type TaskLike } from "@rig/core/task-io";
+import type { TaskDependencyProjection } from "@rig/contracts";
+export type TaskFilters = {
+    readonly assignee?: string;
+    readonly state?: "open" | "closed";
+    readonly limit?: number;
+    readonly search?: string;
+};
+export declare function readTaskStatus(task: TaskLike): string;
+export declare function isReadyTask(task: TaskLike): boolean;
+export declare function asDependencyProjection(task: TaskLike): TaskLike & TaskDependencyProjection;
+export declare function currentLogin(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveAssignee(value: string | undefined | null, env?: NodeJS.ProcessEnv): string | undefined;
+export declare const normalizeAssigneeFilter: typeof resolveAssignee;
+export declare function taskMatchesState(task: TaskLike, state: "open" | "closed" | undefined): boolean;
+export declare function taskMatchesSearch(task: TaskLike, search: string | undefined): boolean;
+export declare function collectAssigneeLogins(value: unknown): string[];
+export declare function taskAssignees(task: TaskLike): string[];
+export declare function taskMatchesAssignee(task: TaskLike, assignee: string | undefined): boolean;
+export declare function applyFilters(tasks: readonly TaskLike[], filters?: TaskFilters): TaskLike[];
+export declare function selectNextReadyTask(tasks: readonly TaskLike[], filters?: TaskFilters): TaskLike | null;
+export declare const selectNextTask: typeof selectNextReadyTask;
+export declare function resolveStartTask(input: {
+    readonly projectRoot: string;
+    readonly taskId?: string | null;
+    readonly next?: boolean;
+    readonly filters?: TaskFilters;
+    readonly listTasks?: (projectRoot: string) => Promise<readonly TaskLike[]>;
+    readonly getTask?: (projectRoot: string, taskId: string) => Promise<TaskLike | null>;
+}): Promise<{
+    readonly taskId: string;
+    readonly task: TaskLike | null;
+}>;

package/dist/src/taskSelection.js

@@ -0,0 +1,181 @@
+// @bun
+// packages/dependency-graph-plugin/src/taskSelection.ts
+import {
+  getTaskForCommand,
+  listTasksForCommand,
+  normalizeTaskId
+} from "@rig/core/task-io";
+
+// packages/dependency-graph-plugin/src/taskRanking.ts
+import {
+  computeTaskDependencyBadges,
+  isTaskTerminalStatus,
+  readTaskScope
+} from "@rig/contracts";
+function priorityValue(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 = 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;
+}
+
+// packages/dependency-graph-plugin/src/taskSelection.ts
+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 };
+}
+export {
+  taskMatchesState,
+  taskMatchesSearch,
+  taskMatchesAssignee,
+  taskAssignees,
+  selectNextTask,
+  selectNextReadyTask,
+  resolveStartTask,
+  resolveAssignee,
+  readTaskStatus,
+  normalizeAssigneeFilter,
+  isReadyTask,
+  currentLogin,
+  collectAssigneeLogins,
+  asDependencyProjection,
+  applyFilters
+};