@h-rig/core 0.0.6-alpha.90 → 0.0.6-alpha.91

package/dist/src/index.d.ts

@@ -6,7 +6,7 @@ export type { PluginHost } from "./plugin-host";
 export { buildRigInitConfigSource, type RigInitConfigInput, } from "./rig-init-builder";
 export type { RegisteredValidator, RigPluginRuntime, RigPluginWithRuntime, TaskSourceFactoryContext, TaskSourceFactoryEntry, ValidatorContext, ValidatorResult, } from "./plugin-runtime";
 export { applyEngineEvent, applyEngineEvents, applyEngineEvent as applyRigEvent, pruneQueueEntries, type ApplyStatus, type EngineEventApplyResult, type EngineEventApplyResult as RigEventApplyResult, } from "./engineReadModelReducer";
-export { pickDefaultWorkspaceId, selectAdhocRuns, selectAdhocRunsForWorkspace, selectApprovalsForRun, selectApprovalsForWorkspace, selectGraphsForWorkspace, selectPendingApprovals, selectPrimaryWorkspace, selectQueueForWorkspace, selectRun, selectRunsByTask, selectRunsForTask, selectRunsForWorkspace, selectTask, selectTasksByStatus, selectTasksByWorkspace, selectTasksForWorkspace, selectTasksGroupedByStatus, selectUserInputsForRun, selectUserInputsForWorkspace, selectWorkspace, selectWorkspaces, } from "./rigSelectors";
-export { buildTaskReferenceIndex, computeTaskBlockingDepths, readTaskMetadataStringList, readTaskSourceIssueId, resolveTaskReference, } from "./taskGraph";
+export { pickDefaultWorkspaceId, projectRunStatusForTaskGrouping, projectTaskStatusForGrouping, projectTaskStatusWithSessions, normalizeTaskAssigneeFilter, readTaskAssigneeLogins, selectAdhocRuns, selectAdhocRunsForWorkspace, selectApprovalsForRun, selectApprovalsForWorkspace, selectGraphsForWorkspace, selectPendingApprovals, selectPrimaryWorkspace, selectQueueForWorkspace, selectRun, selectRunsByTask, selectRunsForTask, selectRunsForWorkspace, selectTask, selectTasksByStatus, selectTasksByWorkspace, selectTasksForWorkspace, selectTasksGroupedByStatus, selectTasksAssignedTo, selectTasksAssignedToMe, selectUserInputsForRun, selectUserInputsForWorkspace, selectWorkspace, selectWorkspaces, type RigTaskSessionProjection, type RigTaskStatusGroup, type RigTaskStatusGroupingInput, } from "./rigSelectors";
+export { buildTaskReferenceIndex, computeTaskBlockingDepths, computeTaskDependencyBadges, isTaskTerminalStatus, readTaskDependencyRefs, readTaskMetadataStringList, readTaskSourceIssueId, resolveTaskReference, selectNextReadyTaskByPriority, type TaskDependencyBadge, type TaskDependencyBadgeKind, type TaskDependencyBadgeSummary, type TaskDependencyProjection, } from "./taskGraph";
 export { extractTaskCode, extractTaskGroupKey, stripTaskCode, } from "./taskGraphCodes";
 export { buildTaskGraphLayout, type TaskGraphEdge, type TaskGraphLane, type TaskGraphLayout, type TaskGraphNode, type TaskGraphStage, } from "./taskGraphLayout";

package/dist/src/index.js

@@ -2140,10 +2140,40 @@ function projectTaskStatusForGrouping(status) {
     case "in_progress":
     case "under_review":
       return "running";
+    case null:
+    case undefined:
+    case "":
+      return "unknown";
     default:
       return status;
   }
 }
+function projectRunStatusForTaskGrouping(status) {
+  switch (status) {
+    case "created":
+    case "queued":
+    case "preparing":
+      return "queued";
+    case "running":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "running";
+    case "needs-attention":
+      return "blocked";
+    case "failed":
+    case "stopped":
+      return "ready";
+    case "completed":
+      return "completed";
+    case null:
+    case undefined:
+      return null;
+  }
+}
 var STATUS_PRIORITY = [
   "running",
   "blocked",
@@ -2155,11 +2185,31 @@ var STATUS_PRIORITY = [
   "cancelled",
   "completed"
 ];
-function selectTasksGroupedByStatus(snapshot, workspaceId) {
-  const tasks = selectTasksByWorkspace(snapshot, workspaceId);
+function taskIdFromSession(session) {
+  return session.taskId ?? session.record.taskId ?? null;
+}
+function latestSessionByTask(sessions) {
+  const byTask = new Map;
+  for (const session of sessions) {
+    const taskId = taskIdFromSession(session);
+    if (!taskId)
+      continue;
+    const existing = byTask.get(taskId);
+    if (!existing || (session.lastEventAt ?? "").localeCompare(existing.lastEventAt ?? "") >= 0) {
+      byTask.set(taskId, session);
+    }
+  }
+  return byTask;
+}
+function projectTaskStatusWithSessions(task, sessionsByTask = new Map) {
+  const sessionStatus = projectRunStatusForTaskGrouping(sessionsByTask.get(task.id)?.status);
+  return sessionStatus ?? projectTaskStatusForGrouping(task.status);
+}
+function groupTasksByProjectedStatus(tasks, sessions = []) {
+  const sessionsByTask = latestSessionByTask(sessions);
   const byStatus = new Map;
   for (const task of tasks) {
-    const projectedStatus = projectTaskStatusForGrouping(task.status);
+    const projectedStatus = projectTaskStatusWithSessions(task, sessionsByTask);
     const group = byStatus.get(projectedStatus);
     if (group) {
       group.push(task);
@@ -2183,6 +2233,69 @@ function selectTasksGroupedByStatus(snapshot, workspaceId) {
   }
   return result;
 }
+function isProjectionGroupingInput(value) {
+  return Boolean(value && typeof value === "object" && !("snapshotSequence" in value) && Array.isArray(value.tasks));
+}
+function selectTasksGroupedByStatus(input, workspaceId) {
+  if (isProjectionGroupingInput(input)) {
+    const filteredTasks = input.workspaceId ? input.tasks.filter((task) => {
+      const workspaceTask = task;
+      return workspaceTask.workspaceId === input.workspaceId;
+    }) : input.tasks;
+    return groupTasksByProjectedStatus(filteredTasks, input.sessions);
+  }
+  const tasks = selectTasksByWorkspace(input, workspaceId ?? null);
+  return groupTasksByProjectedStatus(tasks, []);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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 normalizeTaskAssigneeFilter(assignee, currentUserLogin) {
+  const trimmed = assignee?.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "@me" || trimmed.toLowerCase() === "me") {
+    return currentUserLogin?.trim() ? normalizeLogin(currentUserLogin) : null;
+  }
+  return normalizeLogin(trimmed);
+}
+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 taskMatchesAssigneeFilter(task, assignee, options = {}) {
+  const normalized = normalizeTaskAssigneeFilter(assignee, options.currentUserLogin);
+  if (!normalized)
+    return false;
+  return readTaskAssigneeLogins(task).includes(normalized);
+}
+function selectTasksAssignedTo(tasks, assignee, options = {}) {
+  return tasks.filter((task) => taskMatchesAssigneeFilter(task, assignee, options));
+}
+function selectTasksAssignedToMe(tasks, currentUserLogin) {
+  return selectTasksAssignedTo(tasks, "@me", currentUserLogin === undefined ? {} : { currentUserLogin });
+}
 function selectRun(snapshot, runId) {
   if (!runId)
     return null;
@@ -2244,17 +2357,45 @@ function selectUserInputsForWorkspace(snapshot, workspaceId) {
   return (snapshot.userInputs ?? []).filter((request) => runIds.has(request.runId));
 }
 // packages/core/src/taskGraph.ts
-function isObjectRecord(value) {
+function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readTaskMetadataStringList(task, key) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const value = metadata?.[key];
+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 = isObjectRecord2(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 readTaskDependencyRefs(task) {
+  return unique([
+    ...readTaskMetadataStringList(task, "dependencies"),
+    ...readTaskMetadataStringList(task, "parentChildDeps")
+  ]);
+}
 function readTaskSourceIssueId(task) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : null;
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord2(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))
@@ -2284,11 +2425,7 @@ function computeTaskBlockingDepths(tasks) {
     if (!task)
       return 0;
     stack.add(taskId);
-    const refs = [
-      ...readTaskMetadataStringList(task, "dependencies"),
-      ...readTaskMetadataStringList(task, "parentChildDeps")
-    ];
-    const blockers = refs.map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const blockers = readTaskDependencyRefs(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);
@@ -2299,6 +2436,134 @@ function computeTaskBlockingDepths(tasks) {
   }
   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 priorityValue(task) {
+  return typeof task.priority === "number" && Number.isFinite(task.priority) ? task.priority : Number.MAX_SAFE_INTEGER;
+}
+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 readTaskDependencyRefs(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;
+}
+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/core/src/taskGraphCodes.ts
 var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
 function extractTaskCode(title) {
@@ -2338,11 +2603,11 @@ var PALETTE = [
   { bg: "#132c35", border: "#1783a6", edge: "#53c4e5" },
   { bg: "#26310f", border: "#6d9a19", edge: "#a7da42" }
 ];
-function isObjectRecord2(value) {
+function isObjectRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readIssueType(task) {
-  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  const metadata = isObjectRecord3(task.metadata) ? task.metadata : null;
   return typeof metadata?.issueType === "string" ? metadata.issueType : null;
 }
 function isGraphTask(task) {
@@ -2637,6 +2902,8 @@ export {
   selectTasksForWorkspace,
   selectTasksByWorkspace,
   selectTasksByStatus,
+  selectTasksAssignedToMe,
+  selectTasksAssignedTo,
   selectTask,
   selectRunsForWorkspace,
   selectRunsForTask,
@@ -2645,6 +2912,7 @@ export {
   selectQueueForWorkspace,
   selectPrimaryWorkspace,
   selectPendingApprovals,
+  selectNextReadyTaskByPriority,
   selectGraphsForWorkspace,
   selectApprovalsForWorkspace,
   selectApprovalsForRun,
@@ -2653,13 +2921,21 @@ export {
   resolveTaskReference,
   readTaskSourceIssueId,
   readTaskMetadataStringList,
+  readTaskDependencyRefs,
+  readTaskAssigneeLogins,
   pruneQueueEntries,
+  projectTaskStatusWithSessions,
+  projectTaskStatusForGrouping,
+  projectRunStatusForTaskGrouping,
   pickDefaultWorkspaceId,
+  normalizeTaskAssigneeFilter,
+  isTaskTerminalStatus,
   extractTaskGroupKey,
   extractTaskCode,
   definePlugin,
   defineConfig,
   createPluginHost,
+  computeTaskDependencyBadges,
   computeTaskBlockingDepths,
   buildTaskReferenceIndex,
   buildTaskGraphLayout,

package/dist/src/load-config.js

@@ -1,6 +1,6 @@
 // @bun
 // packages/core/src/load-config.ts
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
@@ -38,6 +38,118 @@ function isModuleResolutionError(error) {
 function runningFromCompiledBinary() {
   return import.meta.url.includes("$bunfs");
 }
+function packageNameAndSubpath(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]+:/.test(specifier))
+    return null;
+  const parts = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!packageName)
+    return null;
+  const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+  return { packageName, subpath: rest ? `./${rest}` : "." };
+}
+function exportTargetFromEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const conditions = entry;
+    for (const key of ["bun", "import", "default", "require"]) {
+      if (typeof conditions[key] === "string")
+        return conditions[key];
+    }
+  }
+  return null;
+}
+function patternExportTarget(record, subpath) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function exportTargetFromPackageJson(pkg, subpath) {
+  const exportsField = pkg.exports;
+  const target = (() => {
+    if (typeof exportsField === "string" && subpath === ".")
+      return exportsField;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return null;
+    const record = exportsField;
+    return exportTargetFromEntry(record[subpath] ?? (subpath === "." ? record["."] : undefined)) ?? patternExportTarget(record, subpath);
+  })();
+  if (target)
+    return target;
+  return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
+}
+function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
+  const storeDir = join(nodeModulesDir, ".bun");
+  if (!existsSync(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    for (const entry of readdirSync(storeDir).sort()) {
+      if (!entry.startsWith(`${encoded}@`))
+        continue;
+      const candidate = join(storeDir, entry, "node_modules", packageName);
+      if (existsSync(join(candidate, "package.json")))
+        return candidate;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePackageExportFromDir(packageDir, subpath) {
+  const packageJsonPath = join(packageDir, "package.json");
+  if (!existsSync(packageJsonPath))
+    return null;
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const target = exportTargetFromPackageJson(pkg, subpath);
+    if (target) {
+      const resolved = join(packageDir, target);
+      if (existsSync(resolved))
+        return resolved;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveBarePackageExport(specifier, parentDir) {
+  const parsed = packageNameAndSubpath(specifier);
+  if (!parsed)
+    return null;
+  const packageNames = parsed.packageName.startsWith("@rig/") ? [parsed.packageName, parsed.packageName.replace(/^@rig\//, "@h-rig/")] : [parsed.packageName];
+  let current = parentDir;
+  while (true) {
+    const nodeModulesDir = join(current, "node_modules");
+    for (const packageName of packageNames) {
+      const directPackageDir = join(nodeModulesDir, packageName);
+      const resolvedDirect = resolvePackageExportFromDir(directPackageDir, parsed.subpath);
+      if (resolvedDirect)
+        return resolvedDirect;
+      const bunStorePackageDir = resolvePackageDirFromBunStore(packageName, nodeModulesDir);
+      if (bunStorePackageDir) {
+        const resolvedFromStore = resolvePackageExportFromDir(bunStorePackageDir, parsed.subpath);
+        if (resolvedFromStore)
+          return resolvedFromStore;
+      }
+    }
+    const next = dirname(current);
+    if (next === current)
+      break;
+    current = next;
+  }
+  return null;
+}
 var runtimeBundleQueue = Promise.resolve();
 function enqueueRuntimeBundle(operation) {
   const next = runtimeBundleQueue.then(operation, operation);
@@ -67,16 +179,20 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
     setup(build) {
       build.onResolve({ filter: /^@rig\// }, (args) => {
         const candidates = [
-          [args.path, configDir],
           [args.path, hostDir],
-          [args.path.replace(/^@rig\//, "@h-rig/"), hostDir]
+          [args.path.replace(/^@rig\//, "@h-rig/"), hostDir],
+          [args.path, configDir]
         ];
         for (const [specifier, parent] of candidates) {
           try {
-            const resolved = bun.resolveSync?.(specifier, parent);
+            const resolved = bun.resolveSync?.(specifier, parent) ?? resolveBarePackageExport(specifier, parent);
             if (resolved)
               return { path: resolved };
-          } catch {}
+          } catch {
+            const resolved = resolveBarePackageExport(specifier, parent);
+            if (resolved)
+              return { path: resolved };
+          }
         }
         return;
       });
@@ -85,10 +201,13 @@ async function importConfigViaRuntimeBundleUnserialized(configPath) {
           return;
         const parent = args.importer ? dirname(args.importer) : configDir;
         try {
-          const resolved = bun.resolveSync?.(args.path, parent);
+          const resolved = bun.resolveSync?.(args.path, parent) ?? resolveBarePackageExport(args.path, parent);
           if (resolved)
             return { path: resolved };
         } catch {
+          const resolved = resolveBarePackageExport(args.path, parent);
+          if (resolved)
+            return { path: resolved };
           return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
         }
         return;
@@ -132,6 +251,11 @@ async function loadConfig(cwd) {
         if (runningFromCompiledBinary()) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
+        const source = readFileSync(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
         try {
           return await import(pathToFileURL(p).href);
         } catch (error) {

package/dist/src/plugin-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { HookImplementation, RegisteredTaskSource, RigPlugin, TaskSourceConfig, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
+import type { HookImplementation, RegisteredTaskSource, RigConfig, RigPlugin, TaskSourceConfig, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
 export interface ValidatorResult {
     id: string;
     passed: boolean;
@@ -25,6 +25,12 @@ export interface RegisteredValidator extends ValidatorRegistration {
  */
 export interface TaskSourceFactoryContext {
     projectRoot: string;
+    /**
+     * Full project config for adapters that need source-adjacent top-level
+     * settings (for example github.projects). Factories should still treat
+     * TaskSourceConfig as the primary adapter config.
+     */
+    rigConfig?: RigConfig;
 }
 /**
  * Executable task-source factory contributed by a plugin. A plugin

package/dist/src/rigSelectors.d.ts

@@ -1,4 +1,5 @@
-import type { ArtifactSummary, ApprovalSummary, EngineReadModel, GraphSummary, QueueEntry, RemoteConnectionSummary, RemoteEndpoint, RunId, RunSummary, TaskId, TaskStatus, TaskSummary, UserInputRequestSummary, WorkspaceId, WorkspaceSummary } from "@rig/contracts";
+import type { ArtifactSummary, ApprovalSummary, EngineReadModel, GraphSummary, QueueEntry, RemoteConnectionSummary, RemoteEndpoint, RunId, RunJournalProjection, RunStatus, RunSummary, TaskId, TaskStatus, TaskSummary, UserInputRequestSummary, WorkspaceId, WorkspaceSummary } from "@rig/contracts";
+import type { TaskDependencyProjection } from "./taskGraph";
 export declare function selectWorkspaces(snapshot: EngineReadModel | null): readonly WorkspaceSummary[];
 export declare function selectPrimaryWorkspace(snapshot: EngineReadModel | null): WorkspaceSummary | null;
 export declare function pickDefaultWorkspaceId(snapshot: EngineReadModel | null): WorkspaceId | null;
@@ -7,10 +8,35 @@ export declare function selectTask(snapshot: EngineReadModel | null, taskId: Tas
 export declare function selectTasksByWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): TaskSummary[];
 export declare const selectTasksForWorkspace: typeof selectTasksByWorkspace;
 export declare function selectTasksByStatus(snapshot: EngineReadModel | null, status: TaskStatus): TaskSummary[];
+export type RigTaskSessionProjection = Pick<RunJournalProjection, "record" | "status" | "lastEventAt"> & {
+    readonly taskId?: string | null;
+};
+export interface RigTaskStatusGroupingInput<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly tasks: readonly T[];
+    readonly sessions?: readonly RigTaskSessionProjection[];
+    readonly workspaceId?: string | null;
+}
+export interface RigTaskStatusGroup<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly status: string;
+    readonly tasks: readonly T[];
+}
+export declare function projectTaskStatusForGrouping(status: string | null | undefined): string;
+export declare function projectRunStatusForTaskGrouping(status: RunStatus | null | undefined): string | null;
+export declare function projectTaskStatusWithSessions(task: TaskDependencyProjection, sessionsByTask?: ReadonlyMap<string, RigTaskSessionProjection>): string;
 export declare function selectTasksGroupedByStatus(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): Array<{
     status: string;
     tasks: readonly TaskSummary[];
 }>;
+export declare function selectTasksGroupedByStatus<T extends TaskDependencyProjection>(input: RigTaskStatusGroupingInput<T>): Array<RigTaskStatusGroup<T>>;
+export declare function normalizeTaskAssigneeFilter(assignee: string | null | undefined, currentUserLogin?: string | null): string | null;
+export declare function readTaskAssigneeLogins(task: TaskDependencyProjection): readonly string[];
+export declare function taskMatchesAssigneeFilter(task: TaskDependencyProjection, assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): boolean;
+export declare function selectTasksAssignedTo<T extends TaskDependencyProjection>(tasks: readonly T[], assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): T[];
+export declare function selectTasksAssignedToMe<T extends TaskDependencyProjection>(tasks: readonly T[], currentUserLogin: string | null | undefined): T[];
 export declare function selectRun(snapshot: EngineReadModel | null, runId: RunId | null): RunSummary | null;
 export declare function selectRunsByTask(snapshot: EngineReadModel | null, taskId: TaskId | null): RunSummary[];
 export declare const selectRunsForTask: typeof selectRunsByTask;

package/dist/src/rigSelectors.js

@@ -39,10 +39,40 @@ function projectTaskStatusForGrouping(status) {
     case "in_progress":
     case "under_review":
       return "running";
+    case null:
+    case undefined:
+    case "":
+      return "unknown";
     default:
       return status;
   }
 }
+function projectRunStatusForTaskGrouping(status) {
+  switch (status) {
+    case "created":
+    case "queued":
+    case "preparing":
+      return "queued";
+    case "running":
+    case "waiting-approval":
+    case "waiting-user-input":
+    case "paused":
+    case "validating":
+    case "reviewing":
+    case "closing-out":
+      return "running";
+    case "needs-attention":
+      return "blocked";
+    case "failed":
+    case "stopped":
+      return "ready";
+    case "completed":
+      return "completed";
+    case null:
+    case undefined:
+      return null;
+  }
+}
 var STATUS_PRIORITY = [
   "running",
   "blocked",
@@ -54,11 +84,31 @@ var STATUS_PRIORITY = [
   "cancelled",
   "completed"
 ];
-function selectTasksGroupedByStatus(snapshot, workspaceId) {
-  const tasks = selectTasksByWorkspace(snapshot, workspaceId);
+function taskIdFromSession(session) {
+  return session.taskId ?? session.record.taskId ?? null;
+}
+function latestSessionByTask(sessions) {
+  const byTask = new Map;
+  for (const session of sessions) {
+    const taskId = taskIdFromSession(session);
+    if (!taskId)
+      continue;
+    const existing = byTask.get(taskId);
+    if (!existing || (session.lastEventAt ?? "").localeCompare(existing.lastEventAt ?? "") >= 0) {
+      byTask.set(taskId, session);
+    }
+  }
+  return byTask;
+}
+function projectTaskStatusWithSessions(task, sessionsByTask = new Map) {
+  const sessionStatus = projectRunStatusForTaskGrouping(sessionsByTask.get(task.id)?.status);
+  return sessionStatus ?? projectTaskStatusForGrouping(task.status);
+}
+function groupTasksByProjectedStatus(tasks, sessions = []) {
+  const sessionsByTask = latestSessionByTask(sessions);
   const byStatus = new Map;
   for (const task of tasks) {
-    const projectedStatus = projectTaskStatusForGrouping(task.status);
+    const projectedStatus = projectTaskStatusWithSessions(task, sessionsByTask);
     const group = byStatus.get(projectedStatus);
     if (group) {
       group.push(task);
@@ -82,6 +132,69 @@ function selectTasksGroupedByStatus(snapshot, workspaceId) {
   }
   return result;
 }
+function isProjectionGroupingInput(value) {
+  return Boolean(value && typeof value === "object" && !("snapshotSequence" in value) && Array.isArray(value.tasks));
+}
+function selectTasksGroupedByStatus(input, workspaceId) {
+  if (isProjectionGroupingInput(input)) {
+    const filteredTasks = input.workspaceId ? input.tasks.filter((task) => {
+      const workspaceTask = task;
+      return workspaceTask.workspaceId === input.workspaceId;
+    }) : input.tasks;
+    return groupTasksByProjectedStatus(filteredTasks, input.sessions);
+  }
+  const tasks = selectTasksByWorkspace(input, workspaceId ?? null);
+  return groupTasksByProjectedStatus(tasks, []);
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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 normalizeTaskAssigneeFilter(assignee, currentUserLogin) {
+  const trimmed = assignee?.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "@me" || trimmed.toLowerCase() === "me") {
+    return currentUserLogin?.trim() ? normalizeLogin(currentUserLogin) : null;
+  }
+  return normalizeLogin(trimmed);
+}
+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 taskMatchesAssigneeFilter(task, assignee, options = {}) {
+  const normalized = normalizeTaskAssigneeFilter(assignee, options.currentUserLogin);
+  if (!normalized)
+    return false;
+  return readTaskAssigneeLogins(task).includes(normalized);
+}
+function selectTasksAssignedTo(tasks, assignee, options = {}) {
+  return tasks.filter((task) => taskMatchesAssigneeFilter(task, assignee, options));
+}
+function selectTasksAssignedToMe(tasks, currentUserLogin) {
+  return selectTasksAssignedTo(tasks, "@me", currentUserLogin === undefined ? {} : { currentUserLogin });
+}
 function selectRun(snapshot, runId) {
   if (!runId)
     return null;
@@ -247,6 +360,7 @@ function selectConnectedRemoteCount(snapshot) {
   return selectRemoteConnections(snapshot).filter((connection) => connection.status === "connected").length;
 }
 export {
+  taskMatchesAssigneeFilter,
   selectWorkspaces,
   selectWorkspace,
   selectValidationsForTask,
@@ -258,6 +372,8 @@ export {
   selectTasksForWorkspace,
   selectTasksByWorkspace,
   selectTasksByStatus,
+  selectTasksAssignedToMe,
+  selectTasksAssignedTo,
   selectTask,
   selectRuntimeForRun,
   selectRunsForWorkspace,
@@ -289,5 +405,10 @@ export {
   selectAdhocRunsForWorkspace,
   selectAdhocRuns,
   selectActionsForTask,
-  pickDefaultWorkspaceId
+  readTaskAssigneeLogins,
+  projectTaskStatusWithSessions,
+  projectTaskStatusForGrouping,
+  projectRunStatusForTaskGrouping,
+  pickDefaultWorkspaceId,
+  normalizeTaskAssigneeFilter
 };

package/dist/src/taskGraph.d.ts

@@ -1,28 +1,41 @@
 import type { TaskSummary } from "@rig/contracts";
-export declare function readTaskMetadataStringList(task: TaskSummary, key: "dependencies" | "parentChildDeps" | "labels"): string[];
-export declare function readTaskSourceIssueId(task: TaskSummary): string | null;
-export declare function resolveTaskReference(ref: string, tasksById: ReadonlyMap<string, TaskSummary>, taskIdByExternalRef: ReadonlyMap<string, string>, taskIdBySourceIssueId: ReadonlyMap<string, string>): string | null;
-export declare function buildTaskReferenceIndex(tasks: readonly TaskSummary[]): {
-    tasksById: Map<string, {
-        readonly id: string & import("effect/Brand").Brand<"TaskId">;
-        readonly title: string;
-        readonly createdAt: string;
-        readonly updatedAt: string;
-        readonly role: string | null;
-        readonly status: "running" | "ready" | "completed" | "failed" | "draft" | "open" | "queued" | "in_progress" | "under_review" | "blocked" | "unknown" | "cancelled" | "closed";
-        readonly metadata: unknown;
-        readonly description: string;
-        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-        readonly graphId: (string & import("effect/Brand").Brand<"GraphId">) | null;
-        readonly externalId: string | null;
-        readonly priority: number | null;
-        readonly scope: readonly string[];
-        readonly validationKeys: readonly string[];
-        readonly dependencies?: readonly string[] | undefined;
-        readonly sourceIssueId?: string | null | undefined;
-        readonly parentChildDeps?: readonly string[] | undefined;
-    }>;
-    taskIdByExternalRef: Map<string, string & import("effect/Brand").Brand<"TaskId">>;
-    taskIdBySourceIssueId: Map<string, string & import("effect/Brand").Brand<"TaskId">>;
+export type TaskDependencyProjection = Pick<TaskSummary, "id" | "status" | "priority" | "metadata"> & Partial<Pick<TaskSummary, "externalId" | "sourceIssueId" | "dependencies" | "parentChildDeps" | "createdAt" | "updatedAt">> & {
+    readonly title?: string | null;
 };
-export declare function computeTaskBlockingDepths(tasks: readonly TaskSummary[]): Map<string, number>;
+export type TaskDependencyBadgeKind = "blocked" | "ready" | "dependency";
+export interface TaskDependencyBadge {
+    readonly kind: TaskDependencyBadgeKind;
+    readonly label: string;
+    readonly description: string;
+    readonly count?: number;
+    readonly taskIds?: readonly string[];
+}
+export interface TaskDependencyBadgeSummary {
+    readonly taskId: string;
+    readonly blockingDepth: number;
+    readonly dependencyIds: readonly string[];
+    readonly unresolvedDependencyRefs: readonly string[];
+    readonly blockedBy: readonly string[];
+    readonly blocks: readonly string[];
+    readonly blocked: boolean;
+    readonly ready: boolean;
+    readonly dependencyCount: number;
+    readonly dependentCount: number;
+    readonly badges: readonly TaskDependencyBadge[];
+}
+export declare function readTaskMetadataStringList(task: TaskDependencyProjection, key: "dependencies" | "parentChildDeps" | "labels"): string[];
+export declare function readTaskDependencyRefs(task: TaskDependencyProjection): string[];
+export declare function readTaskSourceIssueId(task: TaskDependencyProjection): string | null;
+export declare function resolveTaskReference(ref: string, tasksById: ReadonlyMap<string, TaskDependencyProjection>, taskIdByExternalRef: ReadonlyMap<string, string>, taskIdBySourceIssueId: ReadonlyMap<string, string>): string | null;
+export declare function buildTaskReferenceIndex<T extends TaskDependencyProjection>(tasks: readonly T[]): {
+    readonly tasksById: Map<string, T>;
+    readonly taskIdByExternalRef: Map<string, string>;
+    readonly taskIdBySourceIssueId: Map<string, string>;
+};
+export declare function computeTaskBlockingDepths<T extends TaskDependencyProjection>(tasks: readonly T[]): Map<string, number>;
+export declare function isTaskTerminalStatus(status: string | null | undefined): boolean;
+export declare function computeTaskDependencyBadges(tasks: readonly TaskDependencyProjection[]): Map<string, TaskDependencyBadgeSummary>;
+export declare function selectNextReadyTaskByPriority<T extends TaskDependencyProjection>(tasks: readonly T[], options?: {
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly filter?: (task: T) => boolean;
+}): T | null;

package/dist/src/taskGraph.js

@@ -3,14 +3,42 @@
 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 value = metadata?.[key];
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskDependencyRefs(task) {
+  return unique([
+    ...readTaskMetadataStringList(task, "dependencies"),
+    ...readTaskMetadataStringList(task, "parentChildDeps")
+  ]);
 }
 function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
   const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : 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))
@@ -40,11 +68,7 @@ function computeTaskBlockingDepths(tasks) {
     if (!task)
       return 0;
     stack.add(taskId);
-    const refs = [
-      ...readTaskMetadataStringList(task, "dependencies"),
-      ...readTaskMetadataStringList(task, "parentChildDeps")
-    ];
-    const blockers = refs.map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const blockers = readTaskDependencyRefs(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);
@@ -55,10 +79,142 @@ function computeTaskBlockingDepths(tasks) {
   }
   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 priorityValue(task) {
+  return typeof task.priority === "number" && Number.isFinite(task.priority) ? task.priority : Number.MAX_SAFE_INTEGER;
+}
+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 readTaskDependencyRefs(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;
+}
+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;
+}
 export {
+  selectNextReadyTaskByPriority,
   resolveTaskReference,
   readTaskSourceIssueId,
   readTaskMetadataStringList,
+  readTaskDependencyRefs,
+  isTaskTerminalStatus,
+  computeTaskDependencyBadges,
   computeTaskBlockingDepths,
   buildTaskReferenceIndex
 };

package/dist/src/taskGraphLayout.js

@@ -39,14 +39,33 @@ function stripTaskCode(label) {
 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 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 value = metadata?.[key];
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
 }
 function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
   const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : 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))

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@h-rig/core",
-  "version": "0.0.6-alpha.90",
+  "version": "0.0.6-alpha.91",
   "type": "module",
-  "description": "Rig package",
+  "description": "Config and plugin composition library for Rig's OMP extension ecosystem; not a product host/runtime.",
   "license": "UNLICENSED",
   "files": [
     "dist",
@@ -16,18 +16,6 @@
     "./load-config": {
       "types": "./dist/src/load-config.d.ts",
       "import": "./dist/src/load-config.js"
-    },
-    "./engineReadModelReducer": {
-      "types": "./dist/src/engineReadModelReducer.d.ts",
-      "import": "./dist/src/engineReadModelReducer.js"
-    },
-    "./rigSelectors": {
-      "types": "./dist/src/rigSelectors.d.ts",
-      "import": "./dist/src/rigSelectors.js"
-    },
-    "./taskGraph": {
-      "types": "./dist/src/taskGraph.d.ts",
-      "import": "./dist/src/taskGraph.js"
     }
   },
   "engines": {
@@ -37,7 +25,7 @@
   "module": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.90",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.91",
     "effect": "4.0.0-beta.78"
   }
 }