@h-rig/core 0.0.6-alpha.12 → 0.0.6-alpha.121

package/dist/src/define-config.d.ts

@@ -0,0 +1,18 @@
+import { RigConfig } from "@rig/contracts";
+/**
+ * Author-facing config input: `plugins` and `workspace` are optional and
+ * default to a plugin-less worktree setup, so the minimal documented config
+ * (project + taskSource) works out of the box.
+ */
+export type RigConfigInput = Omit<RigConfig, "plugins" | "workspace"> & {
+    plugins?: RigConfig["plugins"];
+    workspace?: RigConfig["workspace"];
+};
+/** Fill optional top-level sections before Schema decode (which requires them). */
+export declare function applyConfigDefaults(raw: unknown): unknown;
+/**
+ * Validate a Rig config and decode through Schema, preserving each plugin's
+ * `__runtime` channel. Schema decode strips unknown fields, so we capture
+ * the runtime objects before decoding and re-attach them after.
+ */
+export declare function defineConfig(cfg: RigConfigInput): RigConfig;

package/dist/src/define-config.js

@@ -2,6 +2,23 @@
 // packages/core/src/define-config.ts
 import { Schema } from "effect";
 import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
+  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
+  workspace.isolation = workspace.isolation ?? workspace.checkout;
+  workspace.sandbox = workspace.sandbox ?? "enforce";
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
 function defineConfig(cfg) {
   const runtimeByName = new Map;
   const plugins = cfg.plugins ?? [];
@@ -10,7 +27,7 @@ function defineConfig(cfg) {
       runtimeByName.set(plugin.name, plugin.__runtime);
     }
   }
-  const decoded = Schema.decodeUnknownSync(RigConfig)(cfg);
+  const decoded = Schema.decodeUnknownSync(RigConfig)(applyConfigDefaults(cfg));
   const decodedPlugins = decoded.plugins.map((p) => {
     const runtime = runtimeByName.get(p.name);
     if (!runtime)
@@ -20,5 +37,6 @@ function defineConfig(cfg) {
   return { ...decoded, plugins: decodedPlugins };
 }
 export {
-  defineConfig
+  defineConfig,
+  applyConfigDefaults
 };

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

@@ -0,0 +1,9 @@
+import { RigPlugin } from "@rig/contracts";
+import type { RigPluginRuntime, RigPluginWithRuntime } from "./plugin-runtime";
+/**
+ * Define a Rig plugin. The first argument is the schema-validated metadata
+ * (id strings, version, contributions). The optional second argument carries
+ * executable bits (validator `run` functions, etc.) that Schema cannot
+ * represent — they travel alongside the validated metadata as `__runtime`.
+ */
+export declare function definePlugin(meta: RigPlugin, runtime?: RigPluginRuntime): RigPluginWithRuntime;

package/dist/src/define-plugin.js

@@ -43,6 +43,23 @@ function definePlugin(meta, runtime) {
       }
     }
   }
+  const declaredHooks = new Map((validated.contributes?.hooks ?? []).map((h) => [h.id, h]));
+  for (const hookId of Object.keys(runtime.hooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`definePlugin(${validated.name}): hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtime.hooks) {
+    for (const h of declaredHooks.values()) {
+      if (!runtime.hooks[h.id] && !h.command) {
+        throw new Error(`definePlugin(${validated.name}): hook metadata "${h.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
   return { ...validated, __runtime: runtime };
 }
 export {

package/dist/src/engineReadModelReducer.d.ts

@@ -0,0 +1,12 @@
+import { EngineEvent, EngineReadModel, QueueEntry, RunSummary, TaskSummary } from "@rig/contracts";
+type EngineApplyStatus = "applied" | "ignored" | "requires-resync";
+export type ApplyStatus = EngineApplyStatus;
+export interface EngineEventApplyResult {
+    readonly status: EngineApplyStatus;
+    readonly snapshot: EngineReadModel;
+}
+export declare function mapTaskStatusFromRunStatus(status: RunSummary["status"], fallback: TaskSummary["status"]): TaskSummary["status"];
+export declare function applyEngineEvent(snapshot: EngineReadModel, event: EngineEvent): EngineEventApplyResult;
+export declare function applyEngineEvents(snapshot: EngineReadModel, events: ReadonlyArray<EngineEvent>): EngineEventApplyResult;
+export declare function pruneQueueEntries(snapshot: EngineReadModel): QueueEntry[];
+export {};

package/dist/src/engineReadModelReducer.js

@@ -149,7 +149,7 @@ function mapLegacySessionStatusToRunStatus(status) {
     case "error":
       return "failed";
     case "stopped":
-      return "cancelled";
+      return "stopped";
     default:
       return "created";
   }
@@ -185,12 +185,15 @@ function mapTaskStatusFromRunStatus(status, fallback) {
     case "paused":
       return "in_progress";
     case "reviewing":
+    case "closing-out":
       return "under_review";
+    case "needs-attention":
+      return "blocked";
     case "completed":
       return "completed";
     case "failed":
       return "ready";
-    case "cancelled":
+    case "stopped":
       return "cancelled";
   }
 }
@@ -1040,7 +1043,7 @@ function applyEngineEvent(snapshot, event) {
           ...base,
           runs: patchById(base.runs, payload.runId, (run) => ({
             ...run,
-            status: "cancelled",
+            status: "stopped",
             updatedAt: payload.createdAt,
             completedAt: payload.createdAt
           }))

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+export declare const RIG_CORE_PACKAGE = "@rig/core";
+export { definePlugin } from "./define-plugin";
+export { defineConfig } from "./define-config";
+export { createPluginHost } from "./plugin-host";
+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, 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

@@ -43,11 +43,45 @@ function definePlugin(meta, runtime) {
       }
     }
   }
+  const declaredHooks = new Map((validated.contributes?.hooks ?? []).map((h) => [h.id, h]));
+  for (const hookId of Object.keys(runtime.hooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`definePlugin(${validated.name}): hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtime.hooks) {
+    for (const h of declaredHooks.values()) {
+      if (!runtime.hooks[h.id] && !h.command) {
+        throw new Error(`definePlugin(${validated.name}): hook metadata "${h.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
   return { ...validated, __runtime: runtime };
 }
 // packages/core/src/define-config.ts
 import { Schema as Schema2 } from "effect";
 import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
+  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
+  workspace.isolation = workspace.isolation ?? workspace.checkout;
+  workspace.sandbox = workspace.sandbox ?? "enforce";
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
 function defineConfig(cfg) {
   const runtimeByName = new Map;
   const plugins = cfg.plugins ?? [];
@@ -56,7 +90,7 @@ function defineConfig(cfg) {
       runtimeByName.set(plugin.name, plugin.__runtime);
     }
   }
-  const decoded = Schema2.decodeUnknownSync(RigConfig)(cfg);
+  const decoded = Schema2.decodeUnknownSync(RigConfig)(applyConfigDefaults(cfg));
   const decodedPlugins = decoded.plugins.map((p) => {
     const runtime = runtimeByName.get(p.name);
     if (!runtime)
@@ -124,6 +158,24 @@ function assertRuntimeMatchesMetadata(plugin) {
       }
     }
   }
+  const declaredHooks = new Map((plugin.contributes?.hooks ?? []).map((hook) => [hook.id, hook]));
+  const runtimeHooks = plugin.__runtime?.hooks;
+  for (const hookId of Object.keys(runtimeHooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`plugin "${plugin.name}" hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtimeHooks) {
+    for (const hook of declaredHooks.values()) {
+      if (!runtimeHooks[hook.id] && !hook.command) {
+        throw new Error(`plugin "${plugin.name}" hook metadata "${hook.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
 }
 function createPluginHost(plugins) {
   assertUniquePluginNames(plugins);
@@ -257,7 +309,8 @@ function buildRigInitConfigSource(input) {
     lines.push(`  },`);
   }
   lines.push(`  workspace: { mainRepo: ".", isolation: "worktree" },`);
-  lines.push(`  runtime: { harness: "pi", mode: "yolo" },`);
+  const sshTarget = input.sshTarget?.trim();
+  lines.push(sshTarget ? `  runtime: { harness: "pi", mode: "yolo", server: { sshTarget: ${JSON.stringify(sshTarget)} } },` : `  runtime: { harness: "pi", mode: "yolo" },  // server.sshTarget unset = local placement`);
   lines.push(`  planning: { mode: "auto" },`);
   lines.push(`  github: {`);
   lines.push(`    issueUpdates: "lifecycle",`);
@@ -422,7 +475,7 @@ function mapLegacySessionStatusToRunStatus(status) {
     case "error":
       return "failed";
     case "stopped":
-      return "cancelled";
+      return "stopped";
     default:
       return "created";
   }
@@ -458,12 +511,15 @@ function mapTaskStatusFromRunStatus(status, fallback) {
     case "paused":
       return "in_progress";
     case "reviewing":
+    case "closing-out":
       return "under_review";
+    case "needs-attention":
+      return "blocked";
     case "completed":
       return "completed";
     case "failed":
       return "ready";
-    case "cancelled":
+    case "stopped":
       return "cancelled";
   }
 }
@@ -1313,7 +1369,7 @@ function applyEngineEvent(snapshot, event) {
           ...base,
           runs: patchById(base.runs, payload.runId, (run) => ({
             ...run,
-            status: "cancelled",
+            status: "stopped",
             updatedAt: payload.createdAt,
             completedAt: payload.createdAt
           }))
@@ -2085,10 +2141,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",
@@ -2100,11 +2186,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);
@@ -2128,6 +2234,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;
@@ -2189,17 +2358,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))
@@ -2229,11 +2426,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);
@@ -2244,6 +2437,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) {
@@ -2283,11 +2604,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) {
@@ -2582,6 +2903,8 @@ export {
   selectTasksForWorkspace,
   selectTasksByWorkspace,
   selectTasksByStatus,
+  selectTasksAssignedToMe,
+  selectTasksAssignedTo,
   selectTask,
   selectRunsForWorkspace,
   selectRunsForTask,
@@ -2590,6 +2913,7 @@ export {
   selectQueueForWorkspace,
   selectPrimaryWorkspace,
   selectPendingApprovals,
+  selectNextReadyTaskByPriority,
   selectGraphsForWorkspace,
   selectApprovalsForWorkspace,
   selectApprovalsForRun,
@@ -2598,13 +2922,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.d.ts

@@ -0,0 +1,2 @@
+import { RigConfig } from "@rig/contracts";
+export declare function loadConfig(cwd: string): Promise<RigConfig>;