@h-rig/core 0.0.6-alpha.14 → 0.0.6-alpha.140

package/dist/src/index.js

@@ -43,11 +43,76 @@ 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)`);
+      }
+    }
+  }
+  const declaredCapabilities = new Map((validated.contributes?.capabilities ?? []).map((capability) => [capability.id, capability]));
+  for (const capability of runtime.featureCapabilities ?? []) {
+    if (!declaredCapabilities.has(capability.id)) {
+      throw new Error(`definePlugin(${validated.name}): executable capability "${capability.id}" has no matching metadata entry in contributes.capabilities`);
+    }
+  }
+  const declaredPanels = new Map((validated.contributes?.panels ?? []).map((panel) => [panel.id, panel]));
+  for (const panel of runtime.panels ?? []) {
+    const metadata = declaredPanels.get(panel.id);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): executable panel "${panel.id}" has no matching metadata entry in contributes.panels`);
+    }
+    if (metadata.slot !== panel.slot) {
+      throw new Error(`definePlugin(${validated.name}): executable panel "${panel.id}" slot "${panel.slot}" does not match metadata slot "${metadata.slot}"`);
+    }
+    if (metadata.capabilityId !== panel.capabilityId) {
+      throw new Error(`definePlugin(${validated.name}): executable panel "${panel.id}" capabilityId "${panel.capabilityId ?? "(none)"}" does not match metadata capabilityId "${metadata.capabilityId ?? "(none)"}"`);
+    }
+  }
+  const declaredBlockerClassifiers = new Map((validated.contributes?.blockerClassifiers ?? []).map((classifier) => [classifier.id, classifier]));
+  for (const classifier of runtime.blockerClassifiers ?? []) {
+    if (!declaredBlockerClassifiers.has(classifier.id)) {
+      throw new Error(`definePlugin(${validated.name}): executable blocker classifier "${classifier.id}" has no matching metadata entry in contributes.blockerClassifiers`);
+    }
+  }
+  const declaredCliCommands = new Map((validated.contributes?.cliCommands ?? []).map((command) => [command.id, command]));
+  for (const command of runtime.cliCommands ?? []) {
+    if (!declaredCliCommands.has(command.id)) {
+      throw new Error(`definePlugin(${validated.name}): executable cli command "${command.id}" has no matching metadata entry in contributes.cliCommands`);
+    }
+  }
   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 +121,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 +189,59 @@ 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)`);
+      }
+    }
+  }
+  const declaredCapabilities = new Map((plugin.contributes?.capabilities ?? []).map((capability) => [capability.id, capability]));
+  const runtimeCapabilities = new Map((plugin.__runtime?.featureCapabilities ?? []).map((capability) => [capability.id, capability]));
+  for (const capability of runtimeCapabilities.values()) {
+    if (!declaredCapabilities.has(capability.id)) {
+      throw new Error(`plugin "${plugin.name}" executable capability "${capability.id}" has no matching metadata entry in contributes.capabilities`);
+    }
+  }
+  const declaredPanels = new Map((plugin.contributes?.panels ?? []).map((panel) => [panel.id, panel]));
+  const runtimePanels = new Map((plugin.__runtime?.panels ?? []).map((panel) => [panel.id, panel]));
+  for (const panel of runtimePanels.values()) {
+    const metadata = declaredPanels.get(panel.id);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" executable panel "${panel.id}" has no matching metadata entry in contributes.panels`);
+    }
+    if (metadata.slot !== panel.slot) {
+      throw new Error(`plugin "${plugin.name}" executable panel "${panel.id}" slot "${panel.slot}" does not match metadata slot "${metadata.slot}"`);
+    }
+    if (metadata.capabilityId !== panel.capabilityId) {
+      throw new Error(`plugin "${plugin.name}" executable panel "${panel.id}" capabilityId "${panel.capabilityId ?? "(none)"}" does not match metadata capabilityId "${metadata.capabilityId ?? "(none)"}"`);
+    }
+  }
+  const declaredBlockerClassifiers = new Map((plugin.contributes?.blockerClassifiers ?? []).map((classifier) => [classifier.id, classifier]));
+  const runtimeBlockerClassifiers = new Map((plugin.__runtime?.blockerClassifiers ?? []).map((classifier) => [classifier.id, classifier]));
+  for (const classifier of runtimeBlockerClassifiers.values()) {
+    if (!declaredBlockerClassifiers.has(classifier.id)) {
+      throw new Error(`plugin "${plugin.name}" executable blocker classifier "${classifier.id}" has no matching metadata entry in contributes.blockerClassifiers`);
+    }
+  }
+  const declaredCliCommands = new Map((plugin.contributes?.cliCommands ?? []).map((command) => [command.id, command]));
+  const runtimeCliCommands = new Map((plugin.__runtime?.cliCommands ?? []).map((command) => [command.id, command]));
+  for (const command of runtimeCliCommands.values()) {
+    if (!declaredCliCommands.has(command.id)) {
+      throw new Error(`plugin "${plugin.name}" executable cli command "${command.id}" has no matching metadata entry in contributes.cliCommands`);
+    }
+  }
 }
 function createPluginHost(plugins) {
   assertUniquePluginNames(plugins);
@@ -138,8 +256,18 @@ function createPluginHost(plugins) {
   const taskFieldExtensions = [];
   const taskSources = [];
   const cliCommands = [];
+  const capabilities = [];
+  const panels = [];
+  const blockerClassifiers = [];
+  const stages = [];
+  const stageMutations = [];
+  const stageExecutors = {};
   const executableValidators = [];
   const executableTaskSources = [];
+  const executableCapabilities = [];
+  const executablePanels = [];
+  const executableBlockerClassifiers = [];
+  const executableCliCommands = [];
   for (const plugin of plugins) {
     const c = plugin.contributes;
     if (!c)
@@ -151,6 +279,18 @@ function createPluginHost(plugins) {
     if (plugin.__runtime?.taskSources) {
       executableTaskSources.push(...plugin.__runtime.taskSources.map((item) => ({ item, pluginName })));
     }
+    if (plugin.__runtime?.featureCapabilities) {
+      executableCapabilities.push(...plugin.__runtime.featureCapabilities.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.panels) {
+      executablePanels.push(...plugin.__runtime.panels.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.blockerClassifiers) {
+      executableBlockerClassifiers.push(...plugin.__runtime.blockerClassifiers.map((item) => ({ item, pluginName })));
+    }
+    if (plugin.__runtime?.cliCommands) {
+      executableCliCommands.push(...plugin.__runtime.cliCommands.map((item) => ({ item, pluginName })));
+    }
     if (c.validators)
       validators.push(...c.validators.map((item) => ({ item, pluginName })));
     if (c.hooks)
@@ -167,9 +307,25 @@ function createPluginHost(plugins) {
       taskSources.push(...c.taskSources.map((item) => ({ item, pluginName })));
     if (c.cliCommands)
       cliCommands.push(...c.cliCommands.map((item) => ({ item, pluginName })));
+    if (c.capabilities)
+      capabilities.push(...c.capabilities.map((item) => ({ item, pluginName })));
+    if (c.panels)
+      panels.push(...c.panels.map((item) => ({ item, pluginName })));
+    if (c.blockerClassifiers)
+      blockerClassifiers.push(...c.blockerClassifiers.map((item) => ({ item, pluginName })));
+    if (c.stages)
+      stages.push(...c.stages.map((item) => ({ item, pluginName })));
+    if (c.stageMutations)
+      stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
+    if (plugin.__runtime?.stages)
+      Object.assign(stageExecutors, plugin.__runtime.stages);
   }
   indexById(executableValidators, "executableValidator");
   indexById(executableTaskSources, "executableTaskSource");
+  indexById(executableCapabilities, "executableCapability");
+  indexById(executablePanels, "executablePanel");
+  indexById(executableBlockerClassifiers, "executableBlockerClassifier");
+  indexById(executableCliCommands, "executableCliCommand");
   const taskSourceFactoryByKind = new Map;
   const taskSourceKindRegistrant = new Map;
   for (const { item, pluginName } of executableTaskSources) {
@@ -187,6 +343,9 @@ function createPluginHost(plugins) {
   const taskFieldExtMap = indexById(taskFieldExtensions, "taskFieldExtension");
   const taskSourceMap = indexById(taskSources, "taskSource");
   const cliCommandMap = indexById(cliCommands, "cliCommand");
+  const capabilityMap = indexById(capabilities, "capability");
+  const panelMap = indexById(panels, "panel");
+  const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
   const allValidators = validators.map((c) => c.item);
   const allHooks = hooks.map((c) => c.item);
   const allSkills = skills.map((c) => c.item);
@@ -195,8 +354,34 @@ function createPluginHost(plugins) {
   const allTaskFieldExtensions = taskFieldExtensions.map((c) => c.item);
   const allTaskSources = taskSources.map((c) => c.item);
   const allCliCommands = cliCommands.map((c) => c.item);
+  const allStageMutations = stageMutations.map((c) => c.item);
+  const allStages = stages.map((c) => c.item);
+  const allCapabilities = capabilities.map((c) => c.item);
+  const allPanels = panels.map((c) => c.item);
+  const allBlockerClassifiers = blockerClassifiers.map((c) => c.item);
   const allExecutableValidators = executableValidators.map((c) => c.item);
   const allExecutableTaskSources = executableTaskSources.map((c) => c.item);
+  const allExecutableCapabilities = executableCapabilities.map((c) => c.item);
+  const allExecutablePanels = executablePanels.map((c) => c.item);
+  const allExecutableBlockerClassifiers = executableBlockerClassifiers.map((c) => c.item);
+  const allExecutableCliCommands = executableCliCommands.map((c) => c.item);
+  const executableCliCommandByName = new Map;
+  const registerExecutableCliCommandSelector = (selector, contribution) => {
+    const existing = executableCliCommandByName.get(selector);
+    if (existing && existing.item.id !== contribution.item.id) {
+      throw new Error(`duplicate executable CLI selector "${selector}" registered by command "${existing.item.id}" from plugin "${existing.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    executableCliCommandByName.set(selector, contribution);
+  };
+  for (const contribution of executableCliCommands) {
+    const command = contribution.item;
+    const family = command.family ?? command.id;
+    registerExecutableCliCommandSelector(command.id, contribution);
+    registerExecutableCliCommandSelector(family, contribution);
+    for (const alias of command.aliases ?? []) {
+      registerExecutableCliCommandSelector(alias, contribution);
+    }
+  }
   return {
     getValidator: (id) => validatorMap.get(id),
     getHook: (id) => hookMap.get(id),
@@ -206,6 +391,9 @@ function createPluginHost(plugins) {
     getTaskFieldExtension: (id) => taskFieldExtMap.get(id),
     getTaskSource: (id) => taskSourceMap.get(id),
     getCliCommand: (id) => cliCommandMap.get(id),
+    getCapability: (id) => capabilityMap.get(id),
+    getPanel: (id) => panelMap.get(id),
+    getBlockerClassifier: (id) => blockerClassifierMap.get(id),
     listValidators: () => allValidators,
     listHooks: () => allHooks,
     listSkills: () => allSkills,
@@ -214,30 +402,44 @@ function createPluginHost(plugins) {
     listTaskFieldExtensions: () => allTaskFieldExtensions,
     listTaskSources: () => allTaskSources,
     listCliCommands: () => allCliCommands,
+    listCapabilities: () => allCapabilities,
+    listPanels: () => allPanels,
+    listBlockerClassifiers: () => allBlockerClassifiers,
+    listStages: () => allStages,
+    listStageMutations: () => allStageMutations,
+    listStageExecutors: () => stageExecutors,
     listExecutableValidators: () => allExecutableValidators,
     listExecutableTaskSources: () => allExecutableTaskSources,
+    listExecutableCapabilities: () => allExecutableCapabilities,
+    listExecutablePanels: () => allExecutablePanels,
+    listExecutableBlockerClassifiers: () => allExecutableBlockerClassifiers,
+    listExecutableCliCommands: () => allExecutableCliCommands,
+    resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
     resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
   };
 }
 // packages/core/src/rig-init-builder.ts
 function buildRigInitConfigSource(input) {
   const lines = [`import { defineConfig } from "@rig/core";`];
-  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`import standard, { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
-  } else if (input.useStandardPlugin) {
-    lines.push(`import standard from "@rig/standard-plugin";`);
+  if (input.useStandardPlugin) {
+    lines.push(`import { standardProjectPlugins } from "@rig/standard-plugin/bundle";`);
+    if (input.taskSource.kind === "github-issues") {
+      lines.push(`import { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
+    }
   }
   lines.push(``, `export default defineConfig({`);
   const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
   lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
   if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [standard({`);
-    lines.push(`    githubCredentialProvider: createStateGitHubCredentialProvider(),`);
-    lines.push(`    githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
-    lines.push(`    githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
+    lines.push(`  plugins: [...standardProjectPlugins({`);
+    lines.push(`    standard: {`);
+    lines.push(`      githubCredentialProvider: createStateGitHubCredentialProvider(),`);
+    lines.push(`      githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
+    lines.push(`      githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
+    lines.push(`    },`);
     lines.push(`  })],`);
   } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "standard()" : ""}],`);
+    lines.push(`  plugins: [${input.useStandardPlugin ? "...standardProjectPlugins()" : ""}],`);
   }
   if (input.taskSource.kind === "github-issues") {
     lines.push(`  taskSource: {`);
@@ -257,7 +459,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",`);
@@ -283,6 +486,7 @@ import {
   WorkspaceId,
   WorktreeId
 } from "@rig/contracts";
+var CANONICAL_RUNTIME_ADAPTER = "pi";
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -422,7 +626,7 @@ function mapLegacySessionStatusToRunStatus(status) {
     case "error":
       return "failed";
     case "stopped":
-      return "cancelled";
+      return "stopped";
     default:
       return "created";
   }
@@ -458,12 +662,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";
   }
 }
@@ -647,7 +854,7 @@ function applySyntheticRuntimePreparation(snapshot, event) {
     ...existingRun,
     taskId: existingRun.taskId ?? nextTaskId,
     runKind: existingRun.runKind === "adhoc" && nextTaskId ? "task" : existingRun.runKind,
-    runtimeAdapter: "rig-native",
+    runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
     initialPrompt: existingRun.initialPrompt ?? null,
     executionTarget: existingRun.executionTarget ?? "local",
     remoteHostId: existingRun.remoteHostId ?? null,
@@ -663,7 +870,7 @@ function applySyntheticRuntimePreparation(snapshot, event) {
     ...runtimeBase,
     workspaceId: nextWorkspaceId,
     runId: runtimeRunId,
-    adapterKind: "rig-native",
+    adapterKind: CANONICAL_RUNTIME_ADAPTER,
     executionTarget: existingRun.executionTarget ?? "local",
     remoteHostId: existingRun.remoteHostId ?? null,
     status: failed ? "failed" : finished ? "prepared" : "starting",
@@ -712,7 +919,7 @@ function applySyntheticRuntimePrepared(snapshot, event) {
     ...snapshot.runtimes.find((runtime) => runtime.runId === runId) ?? makeRuntimeFromRun(existingRun, event.createdAt),
     workspaceId: nextWorkspaceId,
     runId: runtimeRunId,
-    adapterKind: "rig-native",
+    adapterKind: CANONICAL_RUNTIME_ADAPTER,
     executionTarget: existingRun.executionTarget ?? "local",
     remoteHostId: existingRun.remoteHostId ?? null,
     status: "prepared",
@@ -755,7 +962,7 @@ function applyLegacyProjectEvent(snapshot, event) {
       title,
       rootPath,
       sourceKind: "native",
-      defaultRuntimeAdapter: "codex-app-server",
+      defaultRuntimeAdapter: CANONICAL_RUNTIME_ADAPTER,
       defaultModel: readNullableString(payload, "defaultModel") ?? null,
       createdAt,
       updatedAt
@@ -850,7 +1057,7 @@ function applyLegacyThreadEvent(snapshot, event) {
       runtimeMode: "full-access",
       interactionMode: "default",
       status: "created",
-      runtimeAdapter: "codex-app-server",
+      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
       model,
       initialPrompt: null,
       activeRuntimeId: null,
@@ -1034,7 +1241,7 @@ function applyLegacyThreadEvent(snapshot, event) {
     const providerName = readNullableString(session, "providerName");
     const nextRun = {
       ...existingRun,
-      runtimeAdapter: providerName ?? existingRun.runtimeAdapter,
+      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
       initialPrompt: existingRun.initialPrompt ?? null,
       activeRuntimeId: runtimeIdFromRunId(asRunId(runId)),
       status: mapLegacySessionStatusToRunStatus(readString(session, "status")),
@@ -1047,7 +1254,7 @@ function applyLegacyThreadEvent(snapshot, event) {
       ...snapshot.runtimes.find((runtime) => runtime.runId === runId) ?? makeRuntimeFromRun(nextRun, sessionUpdatedAt),
       workspaceId: existingRun.workspaceId,
       runId: asRunId(runId),
-      adapterKind: providerName ?? existingRun.runtimeAdapter,
+      adapterKind: CANONICAL_RUNTIME_ADAPTER,
       status: mapLegacySessionStatusToRuntimeStatus(readString(session, "status")),
       workspaceDir: existingRun.worktreePath,
       isolationMode: existingRun.worktreePath ? "worktree" : "env",
@@ -1281,7 +1488,7 @@ function applyEngineEvent(snapshot, event) {
         runtimeMode: payload.runtimeMode,
         interactionMode: payload.interactionMode,
         status: "created",
-        runtimeAdapter: payload.runtimeAdapter,
+        runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
         model: payload.model ?? null,
         initialPrompt: payload.initialPrompt ?? null,
         executionTarget: payload.executionTarget ?? (payload.remoteHostId ? "remote" : "local"),
@@ -1313,7 +1520,7 @@ function applyEngineEvent(snapshot, event) {
           ...base,
           runs: patchById(base.runs, payload.runId, (run) => ({
             ...run,
-            status: "cancelled",
+            status: "stopped",
             updatedAt: payload.createdAt,
             completedAt: payload.createdAt
           }))
@@ -1977,7 +2184,7 @@ function applyEngineEvent(snapshot, event) {
       runtimeMode: "full-access",
       interactionMode: "default",
       status: "created",
-      runtimeAdapter: "rig-native",
+      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
       model: null,
       initialPrompt: null,
       activeRuntimeId: runtimeIdFromRunId(asRunId(runId)),
@@ -1997,7 +2204,7 @@ function applyEngineEvent(snapshot, event) {
       workspaceId: asWorkspaceId(workspaceId),
       taskId: asTaskId(taskId),
       runKind: "task",
-      runtimeAdapter: "rig-native",
+      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
       activeRuntimeId: runtimeIdFromRunId(asRunId(runId)),
       updatedAt: event.createdAt
     });
@@ -2085,10 +2292,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 +2337,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 +2385,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;
@@ -2188,18 +2508,120 @@ function selectUserInputsForWorkspace(snapshot, workspaceId) {
   const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
   return (snapshot.userInputs ?? []).filter((request) => runIds.has(request.runId));
 }
+// packages/core/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/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 readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+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 readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function isScopeList(input) {
+  return Array.isArray(input);
+}
+function normalizeScopeInput(input) {
+  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
+}
+function disjointScope(left, right) {
+  const leftScope = new Set(normalizeScopeInput(left));
+  if (leftScope.size === 0)
+    return true;
+  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
 }
 function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
   if (tasksById.has(ref))
@@ -2229,11 +2651,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 = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
     const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
     stack.delete(taskId);
     memo.set(taskId, depth);
@@ -2244,6 +2662,212 @@ 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 readTaskRole(task) {
+  if (typeof task.role === "string" && task.role.trim())
+    return task.role.trim();
+  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
+}
+function readTaskCriticality(task) {
+  const metadata = isObjectRecord2(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 = isObjectRecord2(task.metadata) ? task.metadata : null;
+  return readStringList(metadata?.validation);
+}
+function readTaskQueueWeight(task) {
+  const metadata = isObjectRecord2(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 computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+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;
+}
 // packages/core/src/taskGraphCodes.ts
 var TASK_CODE_RE = /^\[([A-Z0-9]+(?:-[A-Z0-9]+)*)\]\s*/;
 function extractTaskCode(title) {
@@ -2283,12 +2907,15 @@ 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;
-  return typeof metadata?.issueType === "string" ? metadata.issueType : null;
+  const metadata = isObjectRecord3(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.issueType === "string")
+    return metadata.issueType;
+  const raw = isObjectRecord3(metadata?.raw) ? metadata.raw : null;
+  return typeof raw?.issueType === "string" ? raw.issueType : null;
 }
 function isGraphTask(task) {
   return readIssueType(task) !== "epic";
@@ -2535,6 +3162,7 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
         const artifactCount = (snapshot?.artifacts ?? []).filter((artifact) => runIds.has(artifact.runId)).length;
         nodes.push({
           id: task.id,
+          taskId: task.id,
           task,
           rowKey,
           rowLabel: rowLabelByKey.get(rowKey) ?? rowKey,
@@ -2569,6 +3197,631 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
     taskCount: graphTasks.length
   };
 }
+// packages/core/src/stageResolve.ts
+class PipelineUnresolvableError extends Error {
+  cycles;
+  contributors;
+  constructor(message, cycles, contributors) {
+    super(message);
+    this.name = "PipelineUnresolvableError";
+    this.cycles = cycles;
+    this.contributors = contributors;
+  }
+}
+function uniqueSorted(values) {
+  return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function wrapperForMutation(mutation) {
+  return "wrapper" in mutation ? mutation.wrapper : mutation.around;
+}
+function contributorOf(mutation) {
+  if (mutation.contributedBy?.trim())
+    return mutation.contributedBy;
+  if (mutation.op === "wrap") {
+    const wrapper = wrapperForMutation(mutation);
+    if (wrapper.id?.trim())
+      return wrapper.id;
+  }
+  return "anonymous";
+}
+function stableMutationCompare(left, right) {
+  const leftTarget = left.op === "insert" ? left.stage.id : left.id;
+  const rightTarget = right.op === "insert" ? right.stage.id : right.id;
+  const targetDelta = leftTarget.localeCompare(rightTarget);
+  if (targetDelta !== 0)
+    return targetDelta;
+  return contributorOf(left).localeCompare(contributorOf(right));
+}
+function ensureUniqueStageIds(stages) {
+  const seen = new Set;
+  for (const stage of stages) {
+    if (seen.has(stage.id)) {
+      throw new PipelineUnresolvableError(`Duplicate stage id: ${stage.id}`, [], []);
+    }
+    seen.add(stage.id);
+  }
+}
+function assertNoDuplicateMutationTargets(mutations, op) {
+  const seen = new Map;
+  for (const mutation of mutations.filter((entry) => entry.op === op)) {
+    const id = mutation.op === "insert" ? mutation.stage.id : mutation.id;
+    const previous = seen.get(id);
+    if (previous) {
+      throw new PipelineUnresolvableError(`Duplicate ${op} mutation for stage ${id}: ${previous}, ${contributorOf(mutation)}`, [], uniqueSorted([previous, contributorOf(mutation)]));
+    }
+    seen.set(id, contributorOf(mutation));
+  }
+}
+function mergeAnchors(current, incoming) {
+  return uniqueSorted([...current, ...incoming ?? []]);
+}
+function stagePriority(stage) {
+  return typeof stage.priority === "number" && Number.isFinite(stage.priority) ? stage.priority : 0;
+}
+function readyCompare(states) {
+  return (left, right) => {
+    const leftState = states.get(left);
+    const rightState = states.get(right);
+    const priorityDelta = stagePriority(rightState?.stage ?? { id: right }) - stagePriority(leftState?.stage ?? { id: left });
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    if (leftState?.baseIndex !== null && rightState?.baseIndex !== null && leftState?.baseIndex !== rightState?.baseIndex) {
+      return (leftState?.baseIndex ?? 0) - (rightState?.baseIndex ?? 0);
+    }
+    if (leftState?.baseIndex !== null && rightState?.baseIndex === null)
+      return -1;
+    if (leftState?.baseIndex === null && rightState?.baseIndex !== null)
+      return 1;
+    return left.localeCompare(right);
+  };
+}
+function findCycles(nodes, edges) {
+  const adjacency = new Map;
+  for (const node of nodes)
+    adjacency.set(node, []);
+  for (const edge of edges)
+    adjacency.get(edge.from)?.push(edge.to);
+  for (const targets of adjacency.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  let nextIndex = 0;
+  const indexByNode = new Map;
+  const lowByNode = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const cycles = [];
+  const visit = (node) => {
+    indexByNode.set(node, nextIndex);
+    lowByNode.set(node, nextIndex);
+    nextIndex += 1;
+    stack.push(node);
+    onStack.add(node);
+    for (const target of adjacency.get(node) ?? []) {
+      if (!indexByNode.has(target)) {
+        visit(target);
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, lowByNode.get(target) ?? 0));
+      } else if (onStack.has(target)) {
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, indexByNode.get(target) ?? 0));
+      }
+    }
+    if (lowByNode.get(node) !== indexByNode.get(node))
+      return;
+    const component = [];
+    let current;
+    do {
+      current = stack.pop();
+      if (current) {
+        onStack.delete(current);
+        component.push(current);
+      }
+    } while (current && current !== node);
+    const hasSelfLoop = edges.some((edge) => edge.from === node && edge.to === node);
+    if (component.length > 1 || hasSelfLoop) {
+      cycles.push(component.sort((left, right) => left.localeCompare(right)));
+    }
+  };
+  for (const node of [...nodes].sort((left, right) => left.localeCompare(right))) {
+    if (!indexByNode.has(node))
+      visit(node);
+  }
+  return cycles.sort((left, right) => left.join("\x00").localeCompare(right.join("\x00")));
+}
+function topologicalOrder(states, edges) {
+  const nodes = [...states.keys()];
+  const outgoing = new Map;
+  const indegree = new Map;
+  for (const node of nodes) {
+    outgoing.set(node, []);
+    indegree.set(node, 0);
+  }
+  for (const edge of edges) {
+    outgoing.get(edge.from)?.push(edge.to);
+    indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+  }
+  for (const targets of outgoing.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  const compare = readyCompare(states);
+  const ready = nodes.filter((node) => (indegree.get(node) ?? 0) === 0).sort(compare);
+  const order = [];
+  while (ready.length > 0) {
+    const node = ready.shift();
+    if (!node)
+      break;
+    order.push(node);
+    for (const target of outgoing.get(node) ?? []) {
+      const next = (indegree.get(target) ?? 0) - 1;
+      indegree.set(target, next);
+      if (next === 0) {
+        ready.push(target);
+        ready.sort(compare);
+      }
+    }
+  }
+  if (order.length === nodes.length)
+    return order;
+  const cycles = findCycles(nodes, edges);
+  const cycleMembers = new Set(cycles.flat());
+  const contributors = uniqueSorted(edges.filter((edge) => cycleMembers.has(edge.from) && cycleMembers.has(edge.to)).flatMap((edge) => edge.contributors));
+  throw new PipelineUnresolvableError(`Stage pipeline has unresolved cycle: ${cycles.map((cycle) => cycle.join(" -> ")).join("; ")}`, cycles, contributors);
+}
+function composeStageWrappers(state) {
+  const wrappers = state.wrappers.toSorted((left, right) => {
+    const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return left.contributedBy.localeCompare(right.contributedBy);
+  });
+  let stage = state.stage;
+  for (const wrapper of wrappers.toReversed()) {
+    if (wrapper.wrapper.apply)
+      stage = wrapper.wrapper.apply(stage);
+  }
+  return stage;
+}
+function resolveStagePipeline(input) {
+  ensureUniqueStageIds(input.defaultStages);
+  const mutations = [...input.mutations ?? []];
+  assertNoDuplicateMutationTargets(mutations, "insert");
+  assertNoDuplicateMutationTargets(mutations, "replace");
+  const states = new Map;
+  const removedStates = new Map;
+  for (const [index, stage] of input.defaultStages.entries()) {
+    states.set(stage.id, {
+      stage: { ...stage, protected: false },
+      before: [...stage.before ?? []],
+      after: [...stage.after ?? []],
+      baseIndex: index,
+      contributedBy: "default",
+      wrappers: [],
+      droppedAnchors: [],
+      isProtected: false
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "remove").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    if (!state)
+      continue;
+    const removedState = {
+      ...state,
+      removedBy: contributor
+    };
+    removedStates.set(mutation.id, removedState);
+    states.delete(mutation.id);
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "replace").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    if (!state)
+      continue;
+    const replacement = { ...mutation.stage, id: mutation.id, protected: false };
+    states.set(mutation.id, {
+      ...state,
+      stage: replacement,
+      before: mutation.stage.before ? [...mutation.stage.before] : state.before,
+      after: mutation.stage.after ? [...mutation.stage.after] : state.after,
+      replacedBy: contributor,
+      contributedBy: state.contributedBy,
+      isProtected: false
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "insert").sort(stableMutationCompare)) {
+    const contributor = contributorOf(mutation);
+    if (states.has(mutation.stage.id)) {
+      throw new PipelineUnresolvableError(`Inserted stage ${mutation.stage.id} conflicts with an existing stage`, [], [contributor]);
+    }
+    states.set(mutation.stage.id, {
+      stage: { ...mutation.stage, protected: false },
+      before: [...mutation.stage.before ?? []],
+      after: [...mutation.stage.after ?? []],
+      baseIndex: null,
+      contributedBy: contributor,
+      wrappers: [],
+      droppedAnchors: [],
+      isProtected: false
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "reorder").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    if (!state)
+      continue;
+    states.set(mutation.id, {
+      ...state,
+      before: mergeAnchors(state.before, mutation.before),
+      after: mergeAnchors(state.after, mutation.after)
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "wrap").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    const wrapper = wrapperForMutation(mutation);
+    if (!state)
+      continue;
+    states.set(mutation.id, {
+      ...state,
+      wrappers: [...state.wrappers, { contributedBy: contributor, wrapper }]
+    });
+  }
+  const contributorsForAnchor = (stageId, direction, anchor, state) => {
+    const contributors = new Set;
+    if (state.replacedBy)
+      contributors.add(state.replacedBy);
+    for (const mutation of mutations) {
+      if (mutation.op === "reorder" && mutation.id === stageId && (direction === "before" ? mutation.before : mutation.after)?.includes(anchor)) {
+        contributors.add(contributorOf(mutation));
+      }
+      if (mutation.op === "insert" && mutation.stage.id === stageId && (direction === "before" ? mutation.stage.before : mutation.stage.after)?.includes(anchor)) {
+        contributors.add(contributorOf(mutation));
+      }
+    }
+    if (contributors.size === 0)
+      contributors.add(state.contributedBy);
+    return uniqueSorted(contributors);
+  };
+  const edges = [];
+  for (const [stageId, state] of states) {
+    const before = [];
+    const after = [];
+    for (const anchor of state.before) {
+      if (states.has(anchor))
+        before.push(anchor);
+      else {
+        const removed = removedStates.get(anchor);
+        state.droppedAnchors.push({
+          stageId,
+          anchor,
+          direction: "before",
+          reason: removed ? "removed" : "missing",
+          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
+        });
+      }
+    }
+    for (const anchor of state.after) {
+      if (states.has(anchor))
+        after.push(anchor);
+      else {
+        const removed = removedStates.get(anchor);
+        state.droppedAnchors.push({
+          stageId,
+          anchor,
+          direction: "after",
+          reason: removed ? "removed" : "missing",
+          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
+        });
+      }
+    }
+    state.before = uniqueSorted(before);
+    state.after = uniqueSorted(after);
+    for (const target of state.before)
+      edges.push({ from: stageId, to: target, contributors: contributorsForAnchor(stageId, "before", target, state) });
+    for (const source of state.after)
+      edges.push({ from: source, to: stageId, contributors: contributorsForAnchor(stageId, "after", source, state) });
+  }
+  const order = topologicalOrder(states, edges);
+  const stages = [];
+  const record = [];
+  for (const id of order) {
+    const state = states.get(id);
+    if (!state)
+      continue;
+    stages.push(composeStageWrappers(state));
+    const wrappedBy = state.wrappers.toSorted((left, right) => {
+      const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
+      if (priorityDelta !== 0)
+        return priorityDelta;
+      return left.contributedBy.localeCompare(right.contributedBy);
+    }).map((wrapper) => wrapper.contributedBy);
+    record.push({
+      stageId: id,
+      contributedBy: state.contributedBy,
+      ...state.replacedBy ? { replacedBy: state.replacedBy } : {},
+      ...wrappedBy.length > 0 ? { wrappedBy } : {},
+      ...state.droppedAnchors.length > 0 ? { droppedAnchors: state.droppedAnchors.toSorted((left, right) => left.anchor.localeCompare(right.anchor)) } : {},
+      isProtected: state.isProtected
+    });
+  }
+  record.push(...[...removedStates.entries()].toSorted((left, right) => {
+    const leftIndex = left[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
+    const rightIndex = right[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
+    if (leftIndex !== rightIndex)
+      return leftIndex - rightIndex;
+    return left[0].localeCompare(right[0]);
+  }).map(([stageId, state]) => ({
+    stageId,
+    contributedBy: state.contributedBy,
+    ...state.removedBy ? { removedBy: state.removedBy } : {},
+    isProtected: state.isProtected
+  })));
+  return { stages, order, record, cycles: [] };
+}
+// packages/core/src/dependencyGraph.ts
+function uniqueSorted2(values) {
+  return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function deriveGraphId(tasks) {
+  const basis = tasks.map((task) => String(task.id)).toSorted((left, right) => left.localeCompare(right)).join("|");
+  let hash = 2166136261;
+  for (let index = 0;index < basis.length; index += 1) {
+    hash ^= basis.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `graph-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function dedupeEdges(edges) {
+  const byKey = new Map;
+  for (const edge of edges) {
+    byKey.set(`${edge.type}\x00${edge.fromTaskId}\x00${edge.toTaskId}`, edge);
+  }
+  return [...byKey.values()].toSorted((left, right) => {
+    const typeDelta = left.type.localeCompare(right.type);
+    if (typeDelta !== 0)
+      return typeDelta;
+    const fromDelta = left.fromTaskId.localeCompare(right.fromTaskId);
+    if (fromDelta !== 0)
+      return fromDelta;
+    return left.toTaskId.localeCompare(right.toTaskId);
+  });
+}
+function detectBlockingCycles(tasks, edges) {
+  const taskIds = tasks.map((task) => String(task.id)).toSorted((left, right) => left.localeCompare(right));
+  const adjacency = new Map;
+  for (const taskId of taskIds)
+    adjacency.set(taskId, []);
+  for (const edge of edges) {
+    if (edge.type === "blocks")
+      adjacency.get(edge.fromTaskId)?.push(edge.toTaskId);
+  }
+  for (const targets of adjacency.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  let nextIndex = 0;
+  const indexByNode = new Map;
+  const lowByNode = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const cycles = [];
+  const visit = (node) => {
+    indexByNode.set(node, nextIndex);
+    lowByNode.set(node, nextIndex);
+    nextIndex += 1;
+    stack.push(node);
+    onStack.add(node);
+    for (const target of adjacency.get(node) ?? []) {
+      if (!indexByNode.has(target)) {
+        visit(target);
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, lowByNode.get(target) ?? 0));
+      } else if (onStack.has(target)) {
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, indexByNode.get(target) ?? 0));
+      }
+    }
+    if (lowByNode.get(node) !== indexByNode.get(node))
+      return;
+    const component = [];
+    let current;
+    do {
+      current = stack.pop();
+      if (current) {
+        onStack.delete(current);
+        component.push(current);
+      }
+    } while (current && current !== node);
+    const selfLoop = (adjacency.get(node) ?? []).includes(node);
+    if (component.length > 1 || selfLoop)
+      cycles.push(component.sort((left, right) => left.localeCompare(right)));
+  };
+  for (const taskId of taskIds) {
+    if (!indexByNode.has(taskId))
+      visit(taskId);
+  }
+  return cycles.sort((left, right) => left.join("\x00").localeCompare(right.join("\x00")));
+}
+function buildDependencyGraphModel(tasks, options = {}) {
+  const badges = computeTaskDependencyBadges(tasks);
+  const index = buildTaskReferenceIndex(tasks);
+  const edges = [];
+  const unresolvedRefs = [];
+  for (const task of tasks) {
+    for (const ref of readTaskMetadataStringList(task, "dependencies")) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId)
+        edges.push({ fromTaskId: dependencyId, toTaskId: String(task.id), type: "blocks" });
+      else
+        unresolvedRefs.push(ref);
+    }
+    for (const ref of readTaskMetadataStringList(task, "parentChildDeps")) {
+      const parentId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (parentId)
+        edges.push({ fromTaskId: parentId, toTaskId: String(task.id), type: "parent-child" });
+      else
+        unresolvedRefs.push(ref);
+    }
+  }
+  const dedupedEdges = dedupeEdges(edges);
+  const nodes = tasks.map((task) => {
+    const summary = badges.get(task.id);
+    const assignees = readTaskAssigneeLogins(task);
+    const groupKey = extractTaskGroupKey(task.title);
+    return {
+      taskId: String(task.id),
+      title: task.title,
+      status: task.status,
+      priority: task.priority,
+      assignee: assignees[0] ?? null,
+      blockedBy: summary?.blockedBy ?? [],
+      blocks: summary?.blocks ?? [],
+      blockingDepth: summary?.blockingDepth ?? 0,
+      blockerClass: null,
+      actionRiskTier: null,
+      epicKey: groupKey,
+      groupKey,
+      externalId: task.externalId,
+      sourceIssueId: task.sourceIssueId ?? null,
+      scope: task.scope,
+      validationKeys: task.validationKeys
+    };
+  }).toSorted((left, right) => left.taskId.localeCompare(right.taskId));
+  return {
+    graphId: options.graphId ?? deriveGraphId(tasks),
+    nodes,
+    edges: dedupedEdges,
+    layout: buildTaskGraphLayout(options.snapshot ?? null, tasks, { showParentChild: options.showParentChild ?? true }),
+    cycles: detectBlockingCycles(tasks, dedupedEdges),
+    unresolvedRefs: uniqueSorted2(unresolvedRefs),
+    degraded: false,
+    generatedAt: options.generatedAt ?? new Date().toISOString()
+  };
+}
+// packages/core/src/rollups.ts
+import { isOperatorActiveRunStatus } from "@rig/contracts";
+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 isObjectRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readIssueType2(task) {
+  const metadata = isObjectRecord4(task.metadata) ? task.metadata : null;
+  const raw = isObjectRecord4(metadata?.raw) ? metadata.raw : null;
+  const value = raw?.issueType ?? metadata?.issueType;
+  return typeof value === "string" && value.trim() ? value.trim().toLowerCase() : null;
+}
+function isEpicTask(task) {
+  return readIssueType2(task) === "epic";
+}
+function isInFlightTaskStatus(status) {
+  switch (status) {
+    case "queued":
+    case "running":
+    case "in_progress":
+    case "under_review":
+      return true;
+    default:
+      return false;
+  }
+}
+function epicKeyForTask(task, tasksById, resolve) {
+  const parentRef = 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/core/src/index.ts
 var RIG_CORE_PACKAGE = "@rig/core";
@@ -2582,35 +3835,58 @@ export {
   selectTasksForWorkspace,
   selectTasksByWorkspace,
   selectTasksByStatus,
+  selectTasksAssignedToMe,
+  selectTasksAssignedTo,
   selectTask,
   selectRunsForWorkspace,
   selectRunsForTask,
   selectRunsByTask,
   selectRun,
+  selectRankedReadyTasks,
   selectQueueForWorkspace,
   selectPrimaryWorkspace,
   selectPendingApprovals,
+  selectNextReadyTaskByPriority,
   selectGraphsForWorkspace,
   selectApprovalsForWorkspace,
   selectApprovalsForRun,
   selectAdhocRunsForWorkspace,
   selectAdhocRuns,
+  scoreTask,
+  rollupByEpic,
+  rollupByAssignee,
   resolveTaskReference,
+  resolveStagePipeline,
   readTaskSourceIssueId,
+  readTaskScope,
   readTaskMetadataStringList,
+  readTaskDependencyRefs,
+  readTaskBlockingDependencyRefs,
+  readTaskAssigneeLogins,
+  rankTasks,
+  rankReadyTasks,
   pruneQueueEntries,
+  projectTaskStatusWithSessions,
+  projectTaskStatusForGrouping,
+  projectRunStatusForTaskGrouping,
   pickDefaultWorkspaceId,
+  normalizeTaskAssigneeFilter,
+  isTaskTerminalStatus,
   extractTaskGroupKey,
   extractTaskCode,
+  disjointScope,
   definePlugin,
   defineConfig,
   createPluginHost,
+  computeTaskDependencyBadges,
   computeTaskBlockingDepths,
   buildTaskReferenceIndex,
   buildTaskGraphLayout,
   buildRigInitConfigSource,
+  buildDependencyGraphModel,
   applyEngineEvent as applyRigEvent,
   applyEngineEvents,
   applyEngineEvent,
-  RIG_CORE_PACKAGE
+  RIG_CORE_PACKAGE,
+  PipelineUnresolvableError
 };