@h-rig/core 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/index.js

@@ -1,97 +1,10 @@
 // @bun
 // packages/core/src/define-plugin.ts
 import { Schema } from "effect";
-import { RigPlugin } from "@rig/contracts";
-function definePlugin(meta, runtime) {
-  const validated = Schema.decodeUnknownSync(RigPlugin)(meta);
-  if (!runtime) {
-    return validated;
-  }
-  const declaredValidators = new Map((validated.contributes?.validators ?? []).map((v) => [v.id, v]));
-  const runtimeValidators = new Map((runtime.validators ?? []).map((v) => [v.id, v]));
-  for (const v of runtimeValidators.values()) {
-    const metadata = declaredValidators.get(v.id);
-    if (!metadata) {
-      throw new Error(`definePlugin(${validated.name}): executable validator "${v.id}" has no matching metadata entry in contributes.validators`);
-    }
-    if (metadata.category !== v.category) {
-      throw new Error(`definePlugin(${validated.name}): executable validator "${v.id}" category "${v.category}" does not match metadata category "${metadata.category}"`);
-    }
-  }
-  if (runtime.validators) {
-    for (const v of declaredValidators.values()) {
-      if (!runtimeValidators.has(v.id)) {
-        throw new Error(`definePlugin(${validated.name}): validator metadata "${v.id}" has no runtime implementation`);
-      }
-    }
-  }
-  const declaredSources = new Map((validated.contributes?.taskSources ?? []).map((s) => [s.id, s]));
-  const runtimeSources = new Map((runtime.taskSources ?? []).map((s) => [s.id, s]));
-  for (const s of runtimeSources.values()) {
-    const metadata = declaredSources.get(s.id);
-    if (!metadata) {
-      throw new Error(`definePlugin(${validated.name}): executable task source "${s.id}" has no matching metadata entry in contributes.taskSources`);
-    }
-    if (metadata.kind !== s.kind) {
-      throw new Error(`definePlugin(${validated.name}): executable task source "${s.id}" kind "${s.kind}" does not match metadata kind "${metadata.kind}"`);
-    }
-  }
-  if (runtime.taskSources) {
-    for (const s of declaredSources.values()) {
-      if (!runtimeSources.has(s.id)) {
-        throw new Error(`definePlugin(${validated.name}): task source metadata "${s.id}" has no runtime implementation`);
-      }
-    }
-  }
-  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 };
+import { RigPlugin as RigPluginManifest } from "@rig/contracts";
+function definePlugin(plugin) {
+  Schema.decodeUnknownSync(RigPluginManifest)(plugin);
+  return plugin;
 }
 // packages/core/src/define-config.ts
 import { Schema as Schema2 } from "effect";
@@ -144,102 +57,8 @@ function assertUniquePluginNames(plugins) {
     seen.add(plugin.name);
   }
 }
-function assertRuntimeMatchesMetadata(plugin) {
-  const declaredValidators = new Map((plugin.contributes?.validators ?? []).map((validator) => [validator.id, validator]));
-  const runtimeValidators = new Map((plugin?.validators ?? []).map((validator) => [validator.id, validator]));
-  for (const validator of runtimeValidators.values()) {
-    const metadata = declaredValidators.get(validator.id);
-    if (!metadata) {
-      throw new Error(`plugin "${plugin.name}" executable validator "${validator.id}" has no matching metadata entry in contributes.validators`);
-    }
-    if (metadata.category !== validator.category) {
-      throw new Error(`plugin "${plugin.name}" executable validator "${validator.id}" category "${validator.category}" does not match metadata category "${metadata.category}"`);
-    }
-  }
-  if (plugin?.validators) {
-    for (const validator of declaredValidators.values()) {
-      if (!runtimeValidators.has(validator.id)) {
-        throw new Error(`plugin "${plugin.name}" validator metadata "${validator.id}" has no runtime implementation`);
-      }
-    }
-  }
-  const declaredTaskSources = new Map((plugin.contributes?.taskSources ?? []).map((source) => [source.id, source]));
-  const runtimeTaskSources = new Map((plugin?.taskSources ?? []).map((source) => [source.id, source]));
-  for (const source of runtimeTaskSources.values()) {
-    const metadata = declaredTaskSources.get(source.id);
-    if (!metadata) {
-      throw new Error(`plugin "${plugin.name}" executable task source "${source.id}" has no matching metadata entry in contributes.taskSources`);
-    }
-    if (metadata.kind !== source.kind) {
-      throw new Error(`plugin "${plugin.name}" executable task source "${source.id}" kind "${source.kind}" does not match metadata kind "${metadata.kind}"`);
-    }
-  }
-  if (plugin?.taskSources) {
-    for (const source of declaredTaskSources.values()) {
-      if (!runtimeTaskSources.has(source.id)) {
-        throw new Error(`plugin "${plugin.name}" task source metadata "${source.id}" has no runtime implementation`);
-      }
-    }
-  }
-  const declaredHooks = new Map((plugin.contributes?.hooks ?? []).map((hook) => [hook.id, hook]));
-  const runtimeHooks = plugin?.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?.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?.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?.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?.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);
-  for (const plugin of plugins) {
-    assertRuntimeMatchesMetadata(plugin);
-  }
   const validators = [];
   const hooks = [];
   const skills = [];
@@ -251,38 +70,15 @@ function createPluginHost(plugins) {
   const capabilities = [];
   const panels = [];
   const blockerClassifiers = [];
+  const sessionExtensions = [];
   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)
       continue;
     const pluginName = plugin.name;
-    if (plugin?.validators) {
-      executableValidators.push(...plugin.validators.map((item) => ({ item, pluginName })));
-    }
-    if (plugin?.taskSources) {
-      executableTaskSources.push(...plugin.taskSources.map((item) => ({ item, pluginName })));
-    }
-    if (plugin?.featureCapabilities) {
-      executableCapabilities.push(...plugin.featureCapabilities.map((item) => ({ item, pluginName })));
-    }
-    if (plugin?.panels) {
-      executablePanels.push(...plugin.panels.map((item) => ({ item, pluginName })));
-    }
-    if (plugin?.blockerClassifiers) {
-      executableBlockerClassifiers.push(...plugin.blockerClassifiers.map((item) => ({ item, pluginName })));
-    }
-    if (plugin?.cliCommands) {
-      executableCliCommands.push(...plugin.cliCommands.map((item) => ({ item, pluginName })));
-    }
     if (c.validators)
       validators.push(...c.validators.map((item) => ({ item, pluginName })));
     if (c.hooks)
@@ -305,27 +101,17 @@ function createPluginHost(plugins) {
       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.sessionExtensions)
+      sessionExtensions.push(...c.sessionExtensions.map((item) => ({ item, pluginName })));
     if (c.stageMutations)
       stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
-    if (plugin?.stages)
-      Object.assign(stageExecutors, plugin.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) {
-    if (taskSourceFactoryByKind.has(item.kind)) {
-      throw new Error(`duplicate task source kind "${item.kind}": registered by plugins "${taskSourceKindRegistrant.get(item.kind)}" and "${pluginName}"`);
+    if (c.stages) {
+      for (const stage of c.stages) {
+        stages.push({ item: stage, pluginName });
+        if (stage.run)
+          stageExecutors[stage.id] = stage.run;
+      }
     }
-    taskSourceFactoryByKind.set(item.kind, item);
-    taskSourceKindRegistrant.set(item.kind, pluginName);
   }
   const validatorMap = indexById(validators, "validator");
   const hookMap = indexById(hooks, "hook");
@@ -338,6 +124,16 @@ function createPluginHost(plugins) {
   const capabilityMap = indexById(capabilities, "capability");
   const panelMap = indexById(panels, "panel");
   const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
+  indexById(sessionExtensions, "sessionExtension");
+  const taskSourceFactoryByKind = new Map;
+  const taskSourceKindRegistrant = new Map;
+  for (const { item, pluginName } of taskSources) {
+    if (taskSourceFactoryByKind.has(item.kind)) {
+      throw new Error(`duplicate task source kind "${item.kind}": registered by plugins "${taskSourceKindRegistrant.get(item.kind)}" and "${pluginName}"`);
+    }
+    taskSourceFactoryByKind.set(item.kind, item);
+    taskSourceKindRegistrant.set(item.kind, pluginName);
+  }
   const allValidators = validators.map((c) => c.item);
   const allHooks = hooks.map((c) => c.item);
   const allSkills = skills.map((c) => c.item);
@@ -351,12 +147,7 @@ function createPluginHost(plugins) {
   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 allSessionExtensions = sessionExtensions.map((c) => c.item);
   const executableCliCommandByName = new Map;
   const registerExecutableCliCommandSelector = (selector, contribution) => {
     const existing = executableCliCommandByName.get(selector);
@@ -365,7 +156,7 @@ function createPluginHost(plugins) {
     }
     executableCliCommandByName.set(selector, contribution);
   };
-  for (const contribution of executableCliCommands) {
+  for (const contribution of cliCommands) {
     const command = contribution.item;
     const family = command.family ?? command.id;
     registerExecutableCliCommandSelector(command.id, contribution);
@@ -400,3485 +191,23 @@ function createPluginHost(plugins) {
     listStages: () => allStages,
     listStageMutations: () => allStageMutations,
     listStageExecutors: () => stageExecutors,
-    listExecutableValidators: () => allExecutableValidators,
-    listExecutableTaskSources: () => allExecutableTaskSources,
-    listExecutableCapabilities: () => allExecutableCapabilities,
-    listExecutablePanels: () => allExecutablePanels,
-    listExecutableBlockerClassifiers: () => allExecutableBlockerClassifiers,
-    listExecutableCliCommands: () => allExecutableCliCommands,
+    listExecutableValidators: () => allValidators.filter((v) => typeof v.run === "function"),
+    listExecutableTaskSources: () => allTaskSources,
+    listExecutableCapabilities: () => allCapabilities.filter((c) => typeof c.run === "function"),
+    listExecutablePanels: () => allPanels.filter((p) => typeof p.produce === "function"),
+    listExecutableBlockerClassifiers: () => allBlockerClassifiers,
+    listExecutableCliCommands: () => allCliCommands,
+    listSessionExtensions: () => allSessionExtensions,
     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/config";`];
-  if (input.useStandardPlugin) {
-    lines.push(`import { standardPlugins } 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: [...standardPlugins({`);
-    lines.push(`    taskSources: {`);
-    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 ? "...standardPlugins()" : ""}],`);
-  }
-  if (input.taskSource.kind === "github-issues") {
-    lines.push(`  taskSource: {`);
-    lines.push(`    kind: "github-issues",`);
-    lines.push(`    owner: ${JSON.stringify(input.taskSource.owner)},`);
-    lines.push(`    repo: ${JSON.stringify(input.taskSource.repo)},`);
-    lines.push(`    // labels: ["task"],  // uncomment to filter by labels`);
-    lines.push(`    state: "open",`);
-    if (input.taskSource.assignee?.trim()) {
-      lines.push(`    options: { assignee: ${JSON.stringify(input.taskSource.assignee.trim())} },`);
-    }
-    lines.push(`  },`);
-  } else {
-    lines.push(`  taskSource: {`);
-    lines.push(`    kind: "files",`);
-    lines.push(`    path: ${JSON.stringify(input.taskSource.path)},`);
-    lines.push(`  },`);
-  }
-  lines.push(`  workspace: { mainRepo: ".", isolation: "worktree" },`);
-  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",`);
-  lines.push(`    projects: { enabled: false },`);
-  lines.push(`  },`);
-  lines.push(`  automation: { maxValidationAttempts: 30, maxPrFixIterations: 100500 },`);
-  lines.push(`  pr: { mode: "auto", watchChecks: true, autoFixChecks: true, autoFixReview: true },`);
-  lines.push(`  merge: { mode: "auto", method: "repo-default", deleteBranch: "repo-default", bypass: false },`);
-  lines.push(`  issueAnalysis: { enabled: true, harness: "pi", mode: "continuous" },`);
-  lines.push(`});`);
-  lines.push(``);
-  return lines.join(`
-`);
-}
-// packages/core/src/engineReadModelReducer.ts
-import {
-  ActionId,
-  ConversationId,
-  EngineRuntimeId,
-  MessageId,
-  RunId,
-  TaskId,
-  WorkspaceId,
-  WorktreeId
-} from "@rig/contracts";
-var CANONICAL_RUNTIME_ADAPTER = "pi";
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function readString(payload, key) {
-  const value = payload[key];
-  return typeof value === "string" ? value : undefined;
-}
-function readNullableString(payload, key) {
-  const value = payload[key];
-  return typeof value === "string" ? value : value === null ? null : undefined;
-}
-function readRecord(payload, key) {
-  const value = payload[key];
-  return isRecord(value) ? value : undefined;
-}
-function asWorkspaceId(value) {
-  return WorkspaceId.makeUnsafe(value);
-}
-function asTaskId(value) {
-  return TaskId.makeUnsafe(value);
-}
-function asRunId(value) {
-  return RunId.makeUnsafe(value);
-}
-function conversationIdFromRunId(value) {
-  return ConversationId.makeUnsafe(value);
-}
-function asActionId(value) {
-  return ActionId.makeUnsafe(value);
-}
-function runtimeIdFromRunId(value) {
-  return EngineRuntimeId.makeUnsafe(value);
-}
-function worktreeIdFromRunId(value) {
-  return WorktreeId.makeUnsafe(value);
-}
-function asMessageId(value) {
-  return MessageId.makeUnsafe(value);
-}
-function upsertById(items, entry) {
-  const index = items.findIndex((candidate) => candidate.id === entry.id);
-  if (index < 0) {
-    return [...items, entry];
-  }
-  const next = items.slice();
-  next[index] = entry;
-  return next;
-}
-function removeById(items, id) {
-  return items.filter((candidate) => candidate.id !== id);
-}
-function patchById(items, id, updater) {
-  const index = items.findIndex((candidate) => candidate.id === id);
-  if (index < 0) {
-    return items.slice();
-  }
-  const next = items.slice();
-  next[index] = updater(next[index]);
-  return next;
-}
-function upsertByKey(items, entry, key) {
-  const index = items.findIndex((candidate) => candidate[key] === entry[key]);
-  if (index < 0) {
-    return [...items, entry];
-  }
-  const next = items.slice();
-  next[index] = entry;
-  return next;
-}
-function patchByKey(items, keyValue, key, updater) {
-  const index = items.findIndex((candidate) => candidate[key] === keyValue);
-  if (index < 0) {
-    return items.slice();
-  }
-  const next = items.slice();
-  next[index] = updater(next[index]);
-  return next;
-}
-function mergeById(items, incoming) {
-  return incoming.reduce((acc, item) => upsertById(acc, item), [...items]);
-}
-function replaceWorkspaceSlice(items, workspaceId, incoming) {
-  return [...items.filter((item) => item.workspaceId !== workspaceId), ...incoming];
-}
-function withQueuePositions(items) {
-  return items.map((item, index) => Object.assign({}, item, {
-    position: index
-  }));
-}
-function maxIsoDate(left, right) {
-  return left.localeCompare(right) >= 0 ? left : right;
-}
-var REMOTE_HOST_STATUS_ONLINE = new Set([
-  "ready",
-  "busy",
-  "degraded",
-  "draining"
-]);
-function deriveRemoteFleetStatus(hosts, warnings) {
-  if (hosts.length === 0)
-    return "empty";
-  if (warnings.length > 0)
-    return "degraded";
-  if (hosts.some((host) => host.status === "degraded" || host.status === "quarantined")) {
-    return "degraded";
-  }
-  const onlineHostCount = hosts.filter((host) => REMOTE_HOST_STATUS_ONLINE.has(host.status)).length;
-  return onlineHostCount > 0 ? "ready" : "degraded";
-}
-function buildRemoteFleetSummary(input) {
-  const warnings = input.fleet?.warnings ?? [];
-  const manifestCount = input.fleet?.manifestCount ?? 0;
-  const onlineHostCount = input.hosts.filter((host) => REMOTE_HOST_STATUS_ONLINE.has(host.status)).length;
-  return {
-    updatedAt: input.updatedAt,
-    status: deriveRemoteFleetStatus(input.hosts, warnings),
-    manifestCount,
-    hostCount: input.hosts.length,
-    onlineHostCount,
-    hosts: [...input.hosts].sort((left, right) => left.name.localeCompare(right.name)),
-    warnings
-  };
-}
-function toRunMode(interactionMode) {
-  return interactionMode === "plan" ? "supervised" : "interactive";
-}
-function mapLegacySessionStatusToRunStatus(status) {
-  switch (status) {
-    case "starting":
-      return "preparing";
-    case "running":
-      return "running";
-    case "ready":
-      return "completed";
-    case "interrupted":
-      return "paused";
-    case "error":
-      return "failed";
-    case "stopped":
-      return "stopped";
-    default:
-      return "created";
-  }
-}
-function mapLegacySessionStatusToRuntimeStatus(status) {
-  switch (status) {
-    case "starting":
-      return "starting";
-    case "running":
-      return "running";
-    case "interrupted":
-      return "interrupted";
-    case "error":
-      return "failed";
-    default:
-      return "exited";
-  }
-}
-function mapTaskStatusFromRunStatus(status, fallback) {
-  if (fallback === "blocked" || fallback === "cancelled" || fallback === "completed" || fallback === "closed" || fallback === "unknown") {
-    return fallback === "closed" ? "completed" : fallback;
-  }
-  switch (status) {
-    case "created":
-      return fallback;
-    case "queued":
-      return "queued";
-    case "preparing":
-    case "running":
-    case "waiting-approval":
-    case "waiting-user-input":
-    case "validating":
-    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 "stopped":
-      return "cancelled";
-  }
-}
-function withSnapshotMetadata(snapshot, event, next) {
-  return {
-    ...snapshot,
-    ...next,
-    snapshotSequence: Math.max(snapshot.snapshotSequence, event.sequence),
-    updatedAt: maxIsoDate(snapshot.updatedAt, event.createdAt)
-  };
-}
-function ensureConversation(snapshot, run) {
-  const conversationId = conversationIdFromRunId(run.id);
-  if (snapshot.conversations.some((conversation) => conversation.id === conversationId)) {
-    return snapshot;
-  }
-  return {
-    ...snapshot,
-    conversations: [
-      ...snapshot.conversations,
-      {
-        id: conversationId,
-        runId: run.id,
-        title: run.title,
-        createdAt: run.createdAt,
-        updatedAt: run.updatedAt
-      }
-    ]
-  };
-}
-function updateTaskFromRun(snapshot, run) {
-  if (!run.taskId) {
-    return snapshot;
-  }
-  return {
-    ...snapshot,
-    tasks: patchById(snapshot.tasks, run.taskId, (task) => ({
-      ...task,
-      status: mapTaskStatusFromRunStatus(run.status, task.status),
-      updatedAt: maxIsoDate(task.updatedAt, run.updatedAt)
-    }))
-  };
-}
-function applyRun(snapshot, run) {
-  const withConversation = ensureConversation(snapshot, run);
-  const nextRuns = upsertById(withConversation.runs, run);
-  return updateTaskFromRun({ ...withConversation, runs: nextRuns }, run);
-}
-function applyRuntime(snapshot, runtime) {
-  return {
-    ...snapshot,
-    runtimes: upsertById(snapshot.runtimes, runtime)
-  };
-}
-function applyWorktree(snapshot, worktree) {
-  return {
-    ...snapshot,
-    worktrees: upsertById(snapshot.worktrees, worktree)
-  };
-}
-function countPendingApprovals(approvals, runId) {
-  return approvals.filter((approval) => approval.runId === runId && approval.status === "pending").length;
-}
-function countPendingUserInputs(userInputs, actions, runId) {
-  const persistedCount = (userInputs ?? []).filter((request) => request.runId === runId && request.status === "pending").length;
-  if (persistedCount > 0) {
-    return persistedCount;
-  }
-  const openRequestIds = new Set;
-  for (const action of actions) {
-    if (action.runId !== runId || !isRecord(action.payload)) {
-      continue;
-    }
-    const requestId = readString(action.payload, "requestId");
-    if (!requestId) {
-      continue;
-    }
-    if (action.actionType === "user-input.requested") {
-      openRequestIds.add(requestId);
-    }
-    if (action.actionType === "user-input.resolved") {
-      openRequestIds.delete(requestId);
-    }
-  }
-  return openRequestIds.size;
-}
-function reconcileRunCounts(snapshot, runId, statusOverride) {
-  return {
-    ...snapshot,
-    runs: patchById(snapshot.runs, runId, (run) => {
-      const pendingApprovalCount = countPendingApprovals(snapshot.approvals, runId);
-      const pendingUserInputCount = countPendingUserInputs(snapshot.userInputs, snapshot.actions, runId);
-      const nextStatus = statusOverride ?? (pendingApprovalCount > 0 ? "waiting-approval" : pendingUserInputCount > 0 ? "waiting-user-input" : run.status === "waiting-approval" || run.status === "waiting-user-input" ? "running" : run.status);
-      return {
-        ...run,
-        pendingApprovalCount,
-        pendingUserInputCount,
-        status: nextStatus
-      };
-    })
-  };
-}
-function applyApprovalActivity(approvals, runId, action) {
-  if (!isRecord(action.payload)) {
-    return approvals.slice();
-  }
-  const requestId = readString(action.payload, "requestId");
-  if (!requestId) {
-    return approvals.slice();
-  }
-  if (action.actionType === "approval.requested") {
-    const requestKind = readString(action.payload, "requestKind") ?? "command";
-    return upsertById(approvals, {
-      id: requestId,
-      runId,
-      actionId: action.id,
-      requestKind,
-      status: "pending",
-      payload: action.payload,
-      createdAt: action.startedAt,
-      resolvedAt: null
-    });
-  }
-  const shouldResolve = action.actionType === "approval.resolved" || action.actionType === "provider.approval.respond.failed" && ((readString(action.payload, "detail") ?? "").includes("Unknown pending permission request") || (readString(action.payload, "message") ?? "").includes("Unknown pending permission request"));
-  if (!shouldResolve) {
-    return approvals.slice();
-  }
-  return approvals.map((approval) => approval.id === requestId ? {
-    ...approval,
-    status: "resolved",
-    resolvedAt: action.completedAt ?? action.startedAt
-  } : approval);
-}
-function makeRuntimeFromRun(run, occurredAt) {
-  return {
-    id: run.activeRuntimeId ?? runtimeIdFromRunId(run.id),
-    workspaceId: run.workspaceId,
-    runId: run.id,
-    adapterKind: run.runtimeAdapter,
-    executionTarget: run.executionTarget ?? "local",
-    remoteHostId: run.remoteHostId ?? null,
-    status: run.status === "failed" ? "failed" : run.status === "paused" ? "interrupted" : "starting",
-    sandboxMode: "danger-full-access",
-    isolationMode: run.worktreePath ? "worktree" : "env",
-    workspaceDir: run.worktreePath,
-    homeDir: null,
-    tmpDir: null,
-    cacheDir: null,
-    logsDir: null,
-    stateDir: null,
-    sessionDir: null,
-    sessionLogPath: null,
-    pid: null,
-    startedAt: run.startedAt ?? occurredAt,
-    updatedAt: occurredAt,
-    exitedAt: run.completedAt
-  };
-}
-function applySyntheticRuntimePreparation(snapshot, event) {
-  if (!isRecord(event.payload)) {
-    return { status: "ignored", snapshot };
-  }
-  const runId = readString(event.payload, "runId") ?? event.aggregateId;
-  const workspaceId = readString(event.payload, "workspaceId");
-  const taskId = readString(event.payload, "taskId") ?? null;
-  const workspaceDir = readNullableString(event.payload, "workspaceDir");
-  const homeDir = readNullableString(event.payload, "homeDir");
-  const tmpDir = readNullableString(event.payload, "tmpDir");
-  const cacheDir = readNullableString(event.payload, "cacheDir");
-  const branchName = readString(event.payload, "taskExternalId") ?? snapshot.runs.find((run) => run.id === runId)?.branch ?? "task";
-  const failed = event.type.endsWith(".failed");
-  const finished = event.type.endsWith(".finished");
-  const existingRun = snapshot.runs.find((run) => run.id === runId);
-  if (!existingRun || !workspaceId) {
-    return { status: "ignored", snapshot };
-  }
-  const runtimeRunId = asRunId(runId);
-  const nextTaskId = taskId ? asTaskId(taskId) : null;
-  const nextWorkspaceId = asWorkspaceId(workspaceId);
-  const nextRun = {
-    ...existingRun,
-    taskId: existingRun.taskId ?? nextTaskId,
-    runKind: existingRun.runKind === "adhoc" && nextTaskId ? "task" : existingRun.runKind,
-    runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-    initialPrompt: existingRun.initialPrompt ?? null,
-    executionTarget: existingRun.executionTarget ?? "local",
-    remoteHostId: existingRun.remoteHostId ?? null,
-    activeRuntimeId: existingRun.activeRuntimeId ?? runtimeIdFromRunId(runtimeRunId),
-    worktreePath: workspaceDir ?? existingRun.worktreePath,
-    status: failed ? "failed" : finished ? "preparing" : "preparing",
-    errorText: failed ? readString(event.payload, "message") ?? existingRun.errorText : existingRun.errorText,
-    updatedAt: event.createdAt,
-    completedAt: failed ? event.createdAt : existingRun.completedAt
-  };
-  const runtimeBase = snapshot.runtimes.find((runtime) => runtime.runId === runId) ?? makeRuntimeFromRun(nextRun, event.createdAt);
-  const nextRuntime = {
-    ...runtimeBase,
-    workspaceId: nextWorkspaceId,
-    runId: runtimeRunId,
-    adapterKind: CANONICAL_RUNTIME_ADAPTER,
-    executionTarget: existingRun.executionTarget ?? "local",
-    remoteHostId: existingRun.remoteHostId ?? null,
-    status: failed ? "failed" : finished ? "prepared" : "starting",
-    isolationMode: "worktree",
-    workspaceDir: workspaceDir ?? runtimeBase.workspaceDir,
-    homeDir: homeDir ?? runtimeBase.homeDir,
-    tmpDir: tmpDir ?? runtimeBase.tmpDir,
-    cacheDir: cacheDir ?? runtimeBase.cacheDir,
-    updatedAt: event.createdAt,
-    exitedAt: failed ? event.createdAt : runtimeBase.exitedAt
-  };
-  let nextSnapshot = applyRun(snapshot, nextRun);
-  nextSnapshot = applyRuntime(nextSnapshot, nextRuntime);
-  if (workspaceDir) {
-    nextSnapshot = applyWorktree(nextSnapshot, {
-      id: worktreeIdFromRunId(runtimeRunId),
-      workspaceId: nextWorkspaceId,
-      runId: runtimeRunId,
-      taskId: nextRun.taskId,
-      branchName,
-      path: workspaceDir,
-      status: failed ? "failed" : finished ? "prepared" : "preparing",
-      createdAt: existingRun.createdAt,
-      cleanedAt: null
-    });
-  }
-  return {
-    status: "applied",
-    snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-  };
-}
-function applySyntheticRuntimePrepared(snapshot, event) {
-  if (!isRecord(event.payload)) {
-    return { status: "ignored", snapshot };
-  }
-  const runId = readString(event.payload, "runId") ?? event.aggregateId;
-  const workspaceId = readString(event.payload, "workspaceId");
-  const worktreePath = readString(event.payload, "worktreePath");
-  const existingRun = snapshot.runs.find((run) => run.id === runId);
-  if (!existingRun || !workspaceId || !worktreePath) {
-    return { status: "ignored", snapshot };
-  }
-  const runtimeRunId = asRunId(runId);
-  const nextWorkspaceId = asWorkspaceId(workspaceId);
-  let nextSnapshot = applyRuntime(snapshot, {
-    ...snapshot.runtimes.find((runtime) => runtime.runId === runId) ?? makeRuntimeFromRun(existingRun, event.createdAt),
-    workspaceId: nextWorkspaceId,
-    runId: runtimeRunId,
-    adapterKind: CANONICAL_RUNTIME_ADAPTER,
-    executionTarget: existingRun.executionTarget ?? "local",
-    remoteHostId: existingRun.remoteHostId ?? null,
-    status: "prepared",
-    isolationMode: "worktree",
-    workspaceDir: worktreePath,
-    updatedAt: event.createdAt
-  });
-  nextSnapshot = applyWorktree(nextSnapshot, {
-    id: worktreeIdFromRunId(runtimeRunId),
-    workspaceId: nextWorkspaceId,
-    runId: runtimeRunId,
-    taskId: existingRun.taskId,
-    branchName: existingRun.branch ?? "task",
-    path: worktreePath,
-    status: "prepared",
-    createdAt: existingRun.createdAt,
-    cleanedAt: null
-  });
-  return {
-    status: "applied",
-    snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-  };
-}
-function applyLegacyProjectEvent(snapshot, event) {
-  if (!isRecord(event.payload)) {
-    return { status: "ignored", snapshot };
-  }
-  const payload = event.payload;
-  if (event.type === "legacy.project.created") {
-    const workspaceId = readString(payload, "projectId");
-    const title = readString(payload, "title");
-    const rootPath = readString(payload, "workspaceRoot");
-    const createdAt = readString(payload, "createdAt");
-    const updatedAt = readString(payload, "updatedAt");
-    if (!workspaceId || !title || !rootPath || !createdAt || !updatedAt) {
-      return { status: "ignored", snapshot };
-    }
-    const workspace = {
-      id: asWorkspaceId(workspaceId),
-      title,
-      rootPath,
-      sourceKind: "native",
-      defaultRuntimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-      defaultModel: readNullableString(payload, "defaultModel") ?? null,
-      createdAt,
-      updatedAt
-    };
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(snapshot, event, {
-        workspaces: upsertById(snapshot.workspaces, workspace)
-      })
-    };
-  }
-  if (event.type === "legacy.project.meta-updated") {
-    const workspaceId = readString(payload, "projectId");
-    if (!workspaceId) {
-      return { status: "ignored", snapshot };
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(snapshot, event, {
-        workspaces: patchById(snapshot.workspaces, workspaceId, (workspace) => ({
-          ...workspace,
-          title: readString(payload, "title") ?? workspace.title,
-          rootPath: readString(payload, "workspaceRoot") ?? workspace.rootPath,
-          defaultModel: readNullableString(payload, "defaultModel") ?? workspace.defaultModel,
-          updatedAt: readString(payload, "updatedAt") ?? event.createdAt
-        }))
-      })
-    };
-  }
-  if (event.type === "legacy.project.deleted") {
-    const workspaceId = readString(payload, "projectId");
-    if (!workspaceId) {
-      return { status: "ignored", snapshot };
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(snapshot, event, {
-        workspaces: removeById(snapshot.workspaces, workspaceId),
-        graphs: snapshot.graphs.filter((graph) => graph.workspaceId !== workspaceId),
-        tasks: snapshot.tasks.filter((task) => task.workspaceId !== workspaceId),
-        runs: snapshot.runs.filter((run) => run.workspaceId !== workspaceId),
-        runtimes: snapshot.runtimes.filter((runtime) => runtime.workspaceId !== workspaceId),
-        conversations: snapshot.conversations.filter((conversation) => {
-          const run = snapshot.runs.find((candidate) => candidate.id === conversation.runId);
-          return run?.workspaceId !== workspaceId;
-        }),
-        messages: snapshot.messages.filter((message) => {
-          const conversation = snapshot.conversations.find((candidate) => candidate.id === message.conversationId);
-          const run = snapshot.runs.find((candidate) => candidate.id === conversation?.runId);
-          return run?.workspaceId !== workspaceId;
-        }),
-        actions: snapshot.actions.filter((action) => {
-          const run = snapshot.runs.find((candidate) => candidate.id === action.runId);
-          return run?.workspaceId !== workspaceId;
-        }),
-        approvals: snapshot.approvals.filter((approval) => {
-          const run = snapshot.runs.find((candidate) => candidate.id === approval.runId);
-          return run?.workspaceId !== workspaceId;
-        }),
-        queue: snapshot.queue.filter((entry) => {
-          const task = snapshot.tasks.find((candidate) => candidate.id === entry.taskId);
-          return task?.workspaceId !== workspaceId;
-        }),
-        worktrees: snapshot.worktrees.filter((worktree) => worktree.workspaceId !== workspaceId)
-      })
-    };
-  }
-  return { status: "ignored", snapshot };
-}
-function applyLegacyThreadEvent(snapshot, event) {
-  if (!isRecord(event.payload)) {
-    return { status: "ignored", snapshot };
-  }
-  const payload = event.payload;
-  if (event.type === "legacy.thread.created") {
-    const runId = readString(payload, "threadId");
-    const workspaceId = readString(payload, "projectId");
-    const title = readString(payload, "title");
-    const model = readString(payload, "model");
-    const createdAt = readString(payload, "createdAt");
-    const updatedAt = readString(payload, "updatedAt");
-    if (!runId || !workspaceId || !title || !model || !createdAt || !updatedAt) {
-      return { status: "ignored", snapshot };
-    }
-    const run = {
-      id: asRunId(runId),
-      workspaceId: asWorkspaceId(workspaceId),
-      taskId: null,
-      title,
-      runKind: "adhoc",
-      mode: toRunMode(readString(payload, "interactionMode")),
-      runtimeMode: "full-access",
-      interactionMode: "default",
-      status: "created",
-      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-      model,
-      initialPrompt: null,
-      activeRuntimeId: null,
-      latestMessageId: null,
-      pendingApprovalCount: 0,
-      pendingUserInputCount: 0,
-      branch: readNullableString(payload, "branch") ?? null,
-      worktreePath: readNullableString(payload, "worktreePath") ?? null,
-      errorText: null,
-      createdAt,
-      updatedAt,
-      startedAt: null,
-      completedAt: null
-    };
-    let nextSnapshot = applyRun(snapshot, run);
-    if (run.branch && run.worktreePath) {
-      nextSnapshot = applyWorktree(nextSnapshot, {
-        id: worktreeIdFromRunId(asRunId(runId)),
-        workspaceId: asWorkspaceId(workspaceId),
-        runId: asRunId(runId),
-        taskId: null,
-        branchName: run.branch,
-        path: run.worktreePath,
-        status: "active",
-        createdAt,
-        cleanedAt: null
-      });
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-    };
-  }
-  if (event.type === "legacy.thread.deleted") {
-    const runId = readString(payload, "threadId");
-    if (!runId) {
-      return { status: "ignored", snapshot };
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(snapshot, event, {
-        runs: removeById(snapshot.runs, runId),
-        runtimes: snapshot.runtimes.filter((runtime) => runtime.runId !== runId),
-        conversations: snapshot.conversations.filter((conversation) => conversation.runId !== runId),
-        messages: snapshot.messages.filter((message) => message.conversationId !== runId),
-        actions: snapshot.actions.filter((action) => action.runId !== runId),
-        approvals: snapshot.approvals.filter((approval) => approval.runId !== runId),
-        worktrees: snapshot.worktrees.filter((worktree) => worktree.runId !== runId)
-      })
-    };
-  }
-  if (event.type === "legacy.thread.meta-updated") {
-    const runId = readString(payload, "threadId");
-    if (!runId) {
-      return { status: "ignored", snapshot };
-    }
-    let nextSnapshot = {
-      ...snapshot,
-      runs: patchById(snapshot.runs, runId, (run2) => ({
-        ...run2,
-        title: readString(payload, "title") ?? run2.title,
-        model: readString(payload, "model") ?? run2.model,
-        branch: readNullableString(payload, "branch") === undefined ? run2.branch : readNullableString(payload, "branch") ?? null,
-        worktreePath: readNullableString(payload, "worktreePath") === undefined ? run2.worktreePath : readNullableString(payload, "worktreePath") ?? null,
-        updatedAt: readString(payload, "updatedAt") ?? event.createdAt
-      })),
-      conversations: patchById(snapshot.conversations, runId, (conversation) => ({
-        ...conversation,
-        title: readString(payload, "title") ?? conversation.title,
-        updatedAt: readString(payload, "updatedAt") ?? event.createdAt
-      }))
-    };
-    const run = nextSnapshot.runs.find((candidate) => candidate.id === runId);
-    if (run?.worktreePath && run.branch) {
-      nextSnapshot = applyWorktree(nextSnapshot, {
-        id: worktreeIdFromRunId(run.id),
-        workspaceId: run.workspaceId,
-        runId: run.id,
-        taskId: run.taskId,
-        branchName: run.branch,
-        path: run.worktreePath,
-        status: "active",
-        createdAt: run.createdAt,
-        cleanedAt: null
-      });
-    }
-    if (run && run.worktreePath === null) {
-      nextSnapshot = {
-        ...nextSnapshot,
-        worktrees: nextSnapshot.worktrees.filter((worktree) => worktree.runId !== runId)
-      };
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-    };
-  }
-  if (event.type === "legacy.thread.interaction-mode-set") {
-    const runId = readString(payload, "threadId");
-    if (!runId) {
-      return { status: "ignored", snapshot };
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(snapshot, event, {
-        runs: patchById(snapshot.runs, runId, (run) => ({
-          ...run,
-          mode: toRunMode(readString(payload, "interactionMode")),
-          updatedAt: readString(payload, "updatedAt") ?? event.createdAt
-        }))
-      })
-    };
-  }
-  if (event.type === "legacy.thread.runtime-mode-set") {
-    const runId = readString(payload, "threadId");
-    if (!runId) {
-      return { status: "ignored", snapshot };
-    }
-    const runtimeMode = readString(payload, "runtimeMode");
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(snapshot, event, {
-        runtimes: patchById(snapshot.runtimes, runId, (runtime) => ({
-          ...runtime,
-          sandboxMode: runtimeMode === "approval-required" ? "workspace-write" : "danger-full-access",
-          updatedAt: readString(payload, "updatedAt") ?? event.createdAt
-        }))
-      })
-    };
-  }
-  if (event.type === "legacy.thread.message-sent") {
-    const runId = readString(payload, "threadId");
-    const messageId = readString(payload, "messageId");
-    const role = readString(payload, "role");
-    const text = readString(payload, "text");
-    const createdAt = readString(payload, "createdAt");
-    const updatedAt = readString(payload, "updatedAt");
-    if (!runId || !messageId || !role || text === undefined || !createdAt || !updatedAt) {
-      return { status: "ignored", snapshot };
-    }
-    const attachments = Array.isArray(payload.attachments) ? payload.attachments : [];
-    const streaming = payload.streaming === true;
-    const message = {
-      id: asMessageId(messageId),
-      conversationId: conversationIdFromRunId(asRunId(runId)),
-      role: role === "assistant" || role === "system" ? role : "user",
-      text,
-      attachments,
-      state: streaming ? "streaming" : "completed",
-      createdAt,
-      completedAt: streaming ? null : updatedAt
-    };
-    const existingRun = snapshot.runs.find((run) => run.id === runId);
-    if (!existingRun) {
-      return { status: "ignored", snapshot };
-    }
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(ensureConversation({
-        ...snapshot,
-        messages: upsertById(snapshot.messages, message),
-        runs: patchById(snapshot.runs, runId, (run) => ({
-          ...run,
-          latestMessageId: asMessageId(messageId),
-          updatedAt
-        }))
-      }, existingRun), event, {})
-    };
-  }
-  if (event.type === "legacy.thread.session-set") {
-    const runId = readString(event.payload, "threadId");
-    const session = readRecord(event.payload, "session");
-    if (!runId || !session) {
-      return { status: "ignored", snapshot };
-    }
-    const existingRun = snapshot.runs.find((run) => run.id === runId);
-    if (!existingRun) {
-      return { status: "ignored", snapshot };
-    }
-    const sessionUpdatedAt = readString(session, "updatedAt") ?? event.createdAt;
-    const providerName = readNullableString(session, "providerName");
-    const nextRun = {
-      ...existingRun,
-      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-      initialPrompt: existingRun.initialPrompt ?? null,
-      activeRuntimeId: runtimeIdFromRunId(asRunId(runId)),
-      status: mapLegacySessionStatusToRunStatus(readString(session, "status")),
-      errorText: readNullableString(session, "lastError") ?? existingRun.errorText,
-      updatedAt: sessionUpdatedAt,
-      completedAt: readString(session, "status") === "ready" || readString(session, "status") === "stopped" || readString(session, "status") === "error" ? sessionUpdatedAt : existingRun.completedAt
-    };
-    let nextSnapshot = applyRun(snapshot, nextRun);
-    nextSnapshot = applyRuntime(nextSnapshot, {
-      ...snapshot.runtimes.find((runtime) => runtime.runId === runId) ?? makeRuntimeFromRun(nextRun, sessionUpdatedAt),
-      workspaceId: existingRun.workspaceId,
-      runId: asRunId(runId),
-      adapterKind: CANONICAL_RUNTIME_ADAPTER,
-      status: mapLegacySessionStatusToRuntimeStatus(readString(session, "status")),
-      workspaceDir: existingRun.worktreePath,
-      isolationMode: existingRun.worktreePath ? "worktree" : "env",
-      updatedAt: sessionUpdatedAt,
-      exitedAt: readString(session, "status") === "ready" || readString(session, "status") === "stopped" || readString(session, "status") === "error" ? sessionUpdatedAt : null
-    });
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-    };
-  }
-  if (event.type === "legacy.thread.activity-appended") {
-    const runId = readString(event.payload, "threadId");
-    const activity = readRecord(event.payload, "activity");
-    if (!runId || !activity) {
-      return { status: "ignored", snapshot };
-    }
-    const actionId = readString(activity, "id");
-    const actionType = readString(activity, "kind");
-    const title = readString(activity, "summary");
-    const startedAt = readString(activity, "createdAt");
-    if (!actionId || !actionType || !title || !startedAt) {
-      return { status: "ignored", snapshot };
-    }
-    const payload2 = readRecord(activity, "payload") ?? {};
-    const detail = readString(payload2, "detail") ?? null;
-    const action = {
-      id: asActionId(actionId),
-      runId: asRunId(runId),
-      messageId: null,
-      actionType,
-      title,
-      detail,
-      state: "completed",
-      payload: payload2,
-      startedAt,
-      completedAt: startedAt
-    };
-    let nextSnapshot = {
-      ...snapshot,
-      actions: upsertById(snapshot.actions, action),
-      approvals: applyApprovalActivity(snapshot.approvals, asRunId(runId), action),
-      runs: patchById(snapshot.runs, runId, (run) => ({
-        ...run,
-        updatedAt: maxIsoDate(run.updatedAt, startedAt),
-        status: actionType === "engine.runtime.ready" ? "running" : actionType === "engine.runtime.failed" ? "failed" : run.status,
-        errorText: actionType === "engine.runtime.failed" && detail ? detail : run.errorText,
-        completedAt: actionType === "engine.runtime.failed" ? startedAt : run.completedAt
-      }))
-    };
-    nextSnapshot = reconcileRunCounts(nextSnapshot, asRunId(runId));
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-    };
-  }
-  if (event.type === "legacy.thread.reverted") {
-    return { status: "requires-resync", snapshot };
-  }
-  return { status: "ignored", snapshot };
-}
-function applyEngineEvent(snapshot, event) {
-  if (event.sequence <= snapshot.snapshotSequence) {
-    return { status: "ignored", snapshot };
-  }
-  if (event.sequence > snapshot.snapshotSequence + 1) {
-    return { status: "requires-resync", snapshot };
-  }
-  const base = {
-    ...snapshot,
-    snapshotSequence: event.sequence,
-    updatedAt: event.createdAt
-  };
-  const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
-  switch (event.type) {
-    case "WorkspaceRegistered":
-    case "RigWorkspaceImported": {
-      const workspace = {
-        id: payload.workspaceId,
-        title: payload.title,
-        rootPath: payload.rootPath,
-        sourceKind: payload.sourceKind,
-        defaultModel: payload.defaultModel ?? null,
-        topology: undefined,
-        remoteFleet: undefined,
-        serviceFabric: undefined,
-        createdAt: payload.createdAt,
-        updatedAt: payload.createdAt
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: upsertById(base.workspaces, workspace)
-        }
-      };
-    }
-    case "RigStateHydrated": {
-      const workspaceRunIds = new Set([
-        ...base.runs.filter((run) => run.workspaceId === payload.workspaceId).map((run) => run.id),
-        ...(payload.runs ?? []).map((run) => run.id)
-      ]);
-      const withoutWorkspaceRunData = (items) => items.filter((item) => !workspaceRunIds.has(item.runId));
-      const workspaces = payload.rootPath ? patchById(base.workspaces, payload.workspaceId, (workspace) => ({
-        ...workspace,
-        rootPath: payload.rootPath,
-        updatedAt: payload.createdAt
-      })) : base.workspaces;
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces,
-          graphs: upsertById(base.graphs, payload.graph),
-          tasks: replaceWorkspaceSlice(base.tasks, payload.workspaceId, payload.tasks ?? []),
-          runs: replaceWorkspaceSlice(base.runs, payload.workspaceId, payload.runs ?? []),
-          runtimes: replaceWorkspaceSlice(base.runtimes, payload.workspaceId, payload.runtimes ?? []),
-          actions: mergeById(withoutWorkspaceRunData(base.actions), payload.actions ?? []),
-          logs: mergeById(withoutWorkspaceRunData(base.logs), payload.logs ?? []),
-          userInputs: (base.userInputs ?? []).filter((request) => !workspaceRunIds.has(request.runId)),
-          validations: mergeById(withoutWorkspaceRunData(base.validations), payload.validations ?? []),
-          reviews: mergeById(withoutWorkspaceRunData(base.reviews), payload.reviews ?? []),
-          artifacts: mergeById(withoutWorkspaceRunData(base.artifacts), payload.artifacts ?? []),
-          policyDecisions: mergeById(withoutWorkspaceRunData(base.policyDecisions), payload.policyDecisions ?? []),
-          queue: [...payload.queue ?? []]
-        }
-      };
-    }
-    case "WorkspaceTopologyCompiled": {
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: patchById(base.workspaces, payload.workspaceId, (workspace) => ({
-            ...workspace,
-            rootPath: payload.rootPath ?? workspace.rootPath,
-            topology: payload.topology,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "WorkspaceRemoteFleetSynced": {
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: patchById(base.workspaces, payload.workspaceId, (workspace) => ({
-            ...workspace,
-            rootPath: payload.rootPath ?? workspace.rootPath,
-            remoteFleet: payload.remoteFleet,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "WorkspaceServiceFabricSynced": {
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: patchById(base.workspaces, payload.workspaceId, (workspace) => ({
-            ...workspace,
-            rootPath: payload.rootPath ?? workspace.rootPath,
-            serviceFabric: payload.serviceFabric,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "WorkspaceRemoteHostRegistered": {
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: patchById(base.workspaces, payload.workspaceId, (workspace) => {
-            const withoutExisting = (workspace.remoteFleet?.hosts ?? []).filter((host) => host.id !== payload.host.id);
-            return {
-              ...workspace,
-              remoteFleet: buildRemoteFleetSummary({
-                fleet: workspace.remoteFleet,
-                hosts: [...withoutExisting, payload.host],
-                updatedAt: payload.createdAt
-              }),
-              updatedAt: payload.createdAt
-            };
-          })
-        }
-      };
-    }
-    case "WorkspaceRemoteHostStatusUpdated": {
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: patchById(base.workspaces, payload.workspaceId, (workspace) => {
-            const fleet = workspace.remoteFleet;
-            if (!fleet) {
-              return {
-                ...workspace,
-                updatedAt: payload.createdAt
-              };
-            }
-            const hosts = fleet.hosts.map((host) => host.id !== payload.hostId ? host : {
-              ...host,
-              status: payload.status,
-              currentLeaseCount: typeof payload.currentLeaseCount === "number" ? payload.currentLeaseCount : host.currentLeaseCount,
-              lastHeartbeatAt: payload.lastHeartbeatAt ?? host.lastHeartbeatAt
-            });
-            return {
-              ...workspace,
-              remoteFleet: buildRemoteFleetSummary({
-                fleet,
-                hosts,
-                updatedAt: payload.createdAt
-              }),
-              updatedAt: payload.createdAt
-            };
-          })
-        }
-      };
-    }
-    case "RunCreated": {
-      const run = {
-        id: payload.runId,
-        workspaceId: payload.workspaceId,
-        taskId: payload.taskId ?? null,
-        title: payload.title,
-        runKind: payload.runKind,
-        mode: payload.mode,
-        runtimeMode: payload.runtimeMode,
-        interactionMode: payload.interactionMode,
-        status: "created",
-        runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-        model: payload.model ?? null,
-        initialPrompt: payload.initialPrompt ?? null,
-        executionTarget: payload.executionTarget ?? (payload.remoteHostId ? "remote" : "local"),
-        remoteHostId: payload.remoteHostId ?? null,
-        remoteLeaseId: null,
-        remoteLeaseClaimedAt: null,
-        activeRuntimeId: null,
-        latestMessageId: null,
-        pendingApprovalCount: 0,
-        pendingUserInputCount: 0,
-        branch: null,
-        worktreePath: null,
-        errorText: null,
-        createdAt: payload.createdAt,
-        updatedAt: payload.createdAt,
-        startedAt: null,
-        completedAt: null
-      };
-      return {
-        status: "applied",
-        snapshot: { ...base, runs: upsertById(base.runs, run) }
-      };
-    }
-    case "RunInterrupted":
-    case "RunCancelled":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            status: "stopped",
-            updatedAt: payload.createdAt,
-            completedAt: payload.createdAt
-          }))
-        }
-      };
-    case "RunCompleted":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            status: "completed",
-            updatedAt: payload.createdAt,
-            completedAt: payload.createdAt
-          }))
-        }
-      };
-    case "RunStatusSet":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            status: payload.status,
-            updatedAt: payload.createdAt,
-            completedAt: null
-          }))
-        }
-      };
-    case "RunFailed":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            status: "failed",
-            errorText: payload.errorText ?? null,
-            updatedAt: payload.createdAt,
-            completedAt: payload.createdAt
-          }))
-        }
-      };
-    case "RuntimeModeSet":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            runtimeMode: payload.runtimeMode,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    case "InteractionModeSet":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            interactionMode: payload.interactionMode,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    case "ConversationAttached": {
-      const conversation = {
-        id: payload.conversationId,
-        runId: payload.runId,
-        title: payload.title,
-        createdAt: payload.createdAt,
-        updatedAt: payload.createdAt
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          conversations: upsertById(base.conversations, conversation)
-        }
-      };
-    }
-    case "MessageAppended": {
-      const conversation = base.conversations.find((item) => item.runId === payload.runId);
-      if (!conversation) {
-        return { status: "ignored", snapshot: base };
-      }
-      const conversationId = conversation.id;
-      const message = {
-        id: payload.messageId,
-        conversationId,
-        role: payload.role,
-        text: payload.text,
-        attachments: payload.attachments ?? [],
-        state: payload.state ?? "completed",
-        createdAt: payload.createdAt,
-        completedAt: payload.completedAt ?? payload.createdAt
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          messages: upsertById(base.messages, message),
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            latestMessageId: payload.messageId,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "ActionStarted": {
-      const action = {
-        id: payload.actionId,
-        runId: payload.runId,
-        messageId: payload.messageId ?? null,
-        actionType: payload.actionType,
-        title: payload.title,
-        detail: payload.detail ?? null,
-        state: payload.state ?? "running",
-        payload: payload.payload ?? null,
-        startedAt: payload.startedAt,
-        completedAt: null
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          actions: upsertById(base.actions, action)
-        }
-      };
-    }
-    case "ActionCompleted":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          actions: patchById(base.actions, payload.actionId, (action) => ({
-            ...action,
-            state: payload.state,
-            detail: payload.detail ?? null,
-            payload: payload.payload,
-            completedAt: payload.completedAt
-          }))
-        }
-      };
-    case "RunLogAppended": {
-      const log = {
-        id: payload.logId,
-        runId: payload.runId,
-        title: payload.title,
-        detail: payload.detail ?? null,
-        tone: payload.tone,
-        status: payload.status ?? null,
-        payload: payload.payload ?? null,
-        createdAt: payload.createdAt
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          logs: upsertById(base.logs, log),
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "ValidationRecorded":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          validations: upsertById(base.validations, {
-            id: payload.id,
-            runId: payload.runId,
-            taskId: payload.taskId ?? null,
-            validatorKey: payload.validatorKey,
-            status: payload.status,
-            output: payload.output,
-            startedAt: payload.startedAt,
-            completedAt: payload.completedAt ?? null
-          })
-        }
-      };
-    case "ReviewRecorded":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          reviews: upsertById(base.reviews, {
-            id: payload.id,
-            runId: payload.runId,
-            taskId: payload.taskId ?? null,
-            provider: payload.provider,
-            mode: payload.mode,
-            status: payload.status,
-            summary: payload.summary ?? null,
-            output: payload.output,
-            createdAt: payload.createdAt,
-            completedAt: payload.completedAt ?? null
-          })
-        }
-      };
-    case "ArtifactRegistered":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          artifacts: upsertById(base.artifacts, {
-            id: payload.id,
-            runId: payload.runId,
-            taskId: payload.taskId ?? null,
-            kind: payload.kind,
-            label: payload.label,
-            path: payload.path ?? null,
-            url: payload.url ?? null,
-            metadata: payload.metadata ?? {},
-            createdAt: payload.createdAt
-          })
-        }
-      };
-    case "ApprovalRequested": {
-      const run = base.runs.find((item) => item.id === payload.runId);
-      const approval = {
-        id: payload.requestId,
-        runId: payload.runId,
-        actionId: payload.actionId ?? null,
-        requestKind: payload.requestKind,
-        status: "pending",
-        payload: payload.payload ?? null,
-        createdAt: payload.createdAt,
-        resolvedAt: null
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          approvals: upsertById(base.approvals, approval),
-          runs: patchById(base.runs, payload.runId, (item) => ({
-            ...item,
-            pendingApprovalCount: (run?.pendingApprovalCount ?? 0) + 1,
-            status: "waiting-approval",
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "ApprovalResolved": {
-      const approval = base.approvals.find((item) => item.id === payload.requestId && item.runId === payload.runId);
-      if (!approval) {
-        return { status: "applied", snapshot: base };
-      }
-      const run = base.runs.find((item) => item.id === payload.runId);
-      const pendingApprovalCount = run ? Math.max(0, Number(run.pendingApprovalCount) - 1) : 0;
-      const nextStatus = run?.status === "waiting-approval" && pendingApprovalCount === 0 ? "running" : run?.status;
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          approvals: patchById(base.approvals, payload.requestId, (item) => ({
-            ...item,
-            status: "resolved",
-            resolvedAt: payload.createdAt
-          })),
-          runs: patchById(base.runs, payload.runId, (item) => ({
-            ...item,
-            pendingApprovalCount,
-            ...nextStatus ? { status: nextStatus } : {},
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "UserInputRequested": {
-      const run = base.runs.find((item) => item.id === payload.runId);
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          userInputs: upsertById(base.userInputs ?? [], {
-            id: payload.requestId,
-            runId: payload.runId,
-            status: "pending",
-            payload: payload.payload,
-            createdAt: payload.createdAt,
-            resolvedAt: null
-          }),
-          runs: patchById(base.runs, payload.runId, (item) => ({
-            ...item,
-            pendingUserInputCount: (run?.pendingUserInputCount ?? 0) + 1,
-            status: "waiting-user-input",
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "UserInputResolved": {
-      const run = base.runs.find((item) => item.id === payload.runId);
-      const pendingUserInputCount = run ? Math.max(0, Number(run.pendingUserInputCount) - 1) : 0;
-      const nextStatus = run?.status === "waiting-user-input" && pendingUserInputCount === 0 ? "running" : run?.status;
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          userInputs: patchById(base.userInputs ?? [], payload.requestId, (item) => ({
-            ...item,
-            status: "resolved",
-            resolvedAt: payload.createdAt
-          })),
-          runs: patchById(base.runs, payload.runId, (item) => ({
-            ...item,
-            pendingUserInputCount,
-            ...nextStatus ? { status: nextStatus } : {},
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "RuntimePrepared": {
-      const runtime = {
-        id: payload.runtimeId,
-        workspaceId: payload.workspaceId,
-        runId: payload.runId,
-        adapterKind: payload.adapter,
-        executionTarget: payload.executionTarget ?? "local",
-        remoteHostId: payload.remoteHostId ?? null,
-        status: "prepared",
-        sandboxMode: "read-only",
-        isolationMode: "none",
-        workspaceDir: null,
-        homeDir: null,
-        tmpDir: null,
-        cacheDir: null,
-        logsDir: null,
-        stateDir: null,
-        sessionDir: null,
-        sessionLogPath: null,
-        pid: null,
-        startedAt: null,
-        updatedAt: payload.createdAt,
-        exitedAt: null
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runtimes: upsertById(base.runtimes, runtime),
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            status: "preparing",
-            executionTarget: payload.executionTarget ?? run.executionTarget ?? "local",
-            remoteHostId: payload.remoteHostId ?? run.remoteHostId ?? null,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    }
-    case "RunRemoteLeaseClaimed":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            remoteHostId: payload.hostId,
-            remoteLeaseId: payload.leaseId,
-            remoteLeaseClaimedAt: payload.createdAt,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    case "RunRemoteLeaseReleased":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            remoteLeaseId: null,
-            remoteLeaseClaimedAt: null,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    case "RuntimeAttached": {
-      const tasks = payload.taskId == null ? base.tasks : patchById(base.tasks, payload.taskId, (task) => ({
-        ...task,
-        status: "running",
-        updatedAt: payload.createdAt
-      }));
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            activeRuntimeId: payload.runtimeId,
-            status: "running",
-            startedAt: payload.createdAt,
-            updatedAt: payload.createdAt
-          })),
-          runtimes: patchById(base.runtimes, payload.runtimeId, (runtime) => ({
-            ...runtime,
-            status: "running",
-            startedAt: payload.createdAt,
-            updatedAt: payload.createdAt
-          })),
-          tasks
-        }
-      };
-    }
-    case "RuntimeDetached":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            activeRuntimeId: null,
-            updatedAt: payload.createdAt
-          })),
-          runtimes: patchById(base.runtimes, payload.runtimeId, (runtime) => ({
-            ...runtime,
-            status: "exited",
-            exitedAt: payload.createdAt,
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    case "RuntimeMetadataUpdated":
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          runs: patchById(base.runs, payload.runId, (run) => ({
-            ...run,
-            ...payload.branch !== undefined ? { branch: payload.branch } : {},
-            ...payload.worktreePath !== undefined ? { worktreePath: payload.worktreePath } : {},
-            updatedAt: payload.createdAt
-          })),
-          runtimes: patchById(base.runtimes, payload.runtimeId, (runtime) => ({
-            ...runtime,
-            ...payload.sandboxMode !== undefined ? { sandboxMode: payload.sandboxMode } : {},
-            ...payload.isolationMode !== undefined ? { isolationMode: payload.isolationMode } : {},
-            ...payload.workspaceDir !== undefined ? { workspaceDir: payload.workspaceDir } : {},
-            ...payload.homeDir !== undefined ? { homeDir: payload.homeDir } : {},
-            ...payload.tmpDir !== undefined ? { tmpDir: payload.tmpDir } : {},
-            ...payload.cacheDir !== undefined ? { cacheDir: payload.cacheDir } : {},
-            ...payload.logsDir !== undefined ? { logsDir: payload.logsDir } : {},
-            ...payload.stateDir !== undefined ? { stateDir: payload.stateDir } : {},
-            ...payload.sessionDir !== undefined ? { sessionDir: payload.sessionDir } : {},
-            ...payload.sessionLogPath !== undefined ? { sessionLogPath: payload.sessionLogPath } : {},
-            ...payload.pid !== undefined ? { pid: payload.pid } : {},
-            updatedAt: payload.createdAt
-          }))
-        }
-      };
-    case "TaskStatusChanged": {
-      const queue = payload.status === "queued" ? base.queue : withQueuePositions(base.queue.filter((item) => item.taskId !== payload.taskId));
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          tasks: patchById(base.tasks, payload.taskId, (task) => ({
-            ...task,
-            status: payload.status,
-            updatedAt: payload.createdAt
-          })),
-          queue
-        }
-      };
-    }
-    case "TaskEnqueued": {
-      const entry = {
-        taskId: payload.taskId,
-        score: payload.score,
-        unblockCount: 0,
-        position: base.queue.length
-      };
-      const positionedQueue = withQueuePositions([
-        ...base.queue.filter((item) => item.taskId !== payload.taskId),
-        entry
-      ]);
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          tasks: patchById(base.tasks, payload.taskId, (task) => ({
-            ...task,
-            status: "queued",
-            updatedAt: payload.createdAt
-          })),
-          queue: positionedQueue
-        }
-      };
-    }
-    case "RemoteEndpointRegistered": {
-      const endpoint = payload.endpoint;
-      if (!endpoint || !endpoint.id) {
-        return { status: "ignored", snapshot: base };
-      }
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          remoteEndpoints: upsertById(base.remoteEndpoints, endpoint)
-        }
-      };
-    }
-    case "RemoteEndpointRemoved": {
-      const endpointId = payload.endpointId;
-      if (!endpointId) {
-        return { status: "ignored", snapshot: base };
-      }
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          remoteEndpoints: removeById(base.remoteEndpoints, endpointId),
-          remoteConnections: base.remoteConnections.filter((conn) => conn.endpointId !== endpointId),
-          remoteOrchestrations: base.remoteOrchestrations.filter((orch) => orch.endpointId !== endpointId)
-        }
-      };
-    }
-    case "RemoteEndpointUpdated": {
-      const endpointId = payload.endpointId;
-      const updates = payload.updates;
-      if (!endpointId || !updates) {
-        return { status: "ignored", snapshot: base };
-      }
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          remoteEndpoints: patchById(base.remoteEndpoints, endpointId, (endpoint) => ({
-            ...endpoint,
-            ...updates
-          }))
-        }
-      };
-    }
-    case "RemoteConnectionChanged": {
-      const endpointId = payload.endpointId;
-      const status = payload.status;
-      if (!endpointId || !status) {
-        return { status: "ignored", snapshot: base };
-      }
-      const existing = base.remoteConnections.find((conn) => conn.endpointId === endpointId);
-      const connection = {
-        ...existing ?? {
-          endpointId,
-          status,
-          error: null,
-          connectedAt: null,
-          tokenExpiresAt: null,
-          latencyMs: null,
-          subscribedEvents: []
-        },
-        endpointId,
-        status,
-        ...payload.error !== undefined ? { error: payload.error ?? null } : {},
-        ...status === "connected" ? { connectedAt: event.createdAt } : {}
-      };
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          remoteConnections: upsertByKey(base.remoteConnections, connection, "endpointId")
-        }
-      };
-    }
-    case "RemoteWorkspaceHydrated": {
-      const endpointId = payload.endpointId;
-      const workspace = payload.workspace;
-      const tasks = payload.tasks;
-      const graph = payload.graph;
-      if (!endpointId || !workspace) {
-        return { status: "ignored", snapshot: base };
-      }
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          workspaces: upsertById(base.workspaces, workspace),
-          tasks: Array.isArray(tasks) ? replaceWorkspaceSlice(base.tasks, workspace.id, tasks) : base.tasks,
-          graphs: graph ? upsertById(base.graphs, graph) : base.graphs
-        }
-      };
-    }
-    case "RemoteStateRefreshed": {
-      const endpointId = payload.endpointId;
-      const tasks = payload.tasks;
-      if (!endpointId) {
-        return { status: "ignored", snapshot: base };
-      }
-      const remoteWorkspace = base.workspaces.find((ws) => ws.id === `remote-workspace:${endpointId}`);
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          tasks: Array.isArray(tasks) && remoteWorkspace ? replaceWorkspaceSlice(base.tasks, remoteWorkspace.id, tasks) : base.tasks
-        }
-      };
-    }
-    case "RemoteEventReceived":
-      return { status: "applied", snapshot: base };
-    case "RemoteOrchestrationStarted": {
-      const orchestration = payload.orchestration;
-      if (!orchestration || !orchestration.orchestrationId) {
-        return { status: "ignored", snapshot: base };
-      }
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          remoteOrchestrations: upsertByKey(base.remoteOrchestrations, orchestration, "orchestrationId")
-        }
-      };
-    }
-    case "RemoteOrchestrationUpdated": {
-      const orchestrationId = payload.orchestrationId;
-      const state = payload.state;
-      if (!orchestrationId) {
-        return { status: "ignored", snapshot: base };
-      }
-      return {
-        status: "applied",
-        snapshot: {
-          ...base,
-          remoteOrchestrations: patchByKey(base.remoteOrchestrations, orchestrationId, "orchestrationId", (orch) => ({
-            ...orch,
-            ...isRecord(state) ? state : {}
-          }))
-        }
-      };
-    }
-  }
-  if (event.type === "workspace.imported") {
-    return { status: "requires-resync", snapshot };
-  }
-  if (event.type === "task.run-linked") {
-    const payload2 = isRecord(event.payload) ? event.payload : {};
-    const runId = readString(payload2, "runId");
-    const taskId = readString(payload2, "taskId");
-    const workspaceId = readString(payload2, "workspaceId");
-    if (!runId || !taskId || !workspaceId) {
-      return { status: "ignored", snapshot };
-    }
-    const baseRun = snapshot.runs.find((run) => run.id === runId) ?? {
-      id: asRunId(runId),
-      workspaceId: asWorkspaceId(workspaceId),
-      taskId: asTaskId(taskId),
-      title: "Task run",
-      runKind: "task",
-      mode: "interactive",
-      runtimeMode: "full-access",
-      interactionMode: "default",
-      status: "created",
-      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-      model: null,
-      initialPrompt: null,
-      activeRuntimeId: runtimeIdFromRunId(asRunId(runId)),
-      latestMessageId: null,
-      pendingApprovalCount: 0,
-      pendingUserInputCount: 0,
-      branch: null,
-      worktreePath: null,
-      errorText: null,
-      createdAt: event.createdAt,
-      updatedAt: event.createdAt,
-      startedAt: event.createdAt,
-      completedAt: null
-    };
-    const nextSnapshot = applyRun(snapshot, {
-      ...baseRun,
-      workspaceId: asWorkspaceId(workspaceId),
-      taskId: asTaskId(taskId),
-      runKind: "task",
-      runtimeAdapter: CANONICAL_RUNTIME_ADAPTER,
-      activeRuntimeId: runtimeIdFromRunId(asRunId(runId)),
-      updatedAt: event.createdAt
-    });
-    return {
-      status: "applied",
-      snapshot: withSnapshotMetadata(nextSnapshot, event, {})
-    };
-  }
-  if (event.type.startsWith("runtime.prepare.")) {
-    return applySyntheticRuntimePreparation(snapshot, event);
-  }
-  if (event.type === "runtime.prepared") {
-    return applySyntheticRuntimePrepared(snapshot, event);
-  }
-  if (event.type.startsWith("legacy.project.")) {
-    return applyLegacyProjectEvent(snapshot, event);
-  }
-  if (event.type.startsWith("legacy.thread.")) {
-    return applyLegacyThreadEvent(snapshot, event);
-  }
-  return { status: "ignored", snapshot: base };
-}
-function applyEngineEvents(snapshot, events) {
-  let nextSnapshot = snapshot;
-  let requiresResync = false;
-  let applied = false;
-  for (const event of events) {
-    const result = applyEngineEvent(nextSnapshot, event);
-    nextSnapshot = result.snapshot;
-    if (result.status === "requires-resync") {
-      requiresResync = true;
-    }
-    if (result.status === "applied") {
-      applied = true;
-    }
-  }
-  return {
-    status: requiresResync ? "requires-resync" : applied ? "applied" : "ignored",
-    snapshot: nextSnapshot
-  };
-}
-function pruneQueueEntries(snapshot) {
-  return snapshot.queue.filter((entry) => {
-    const task = snapshot.tasks.find((candidate) => candidate.id === entry.taskId);
-    return task?.status !== "running" && task?.status !== "in_progress" && task?.status !== "under_review";
-  });
-}
-// packages/core/src/rigSelectors.ts
-function selectWorkspaces(snapshot) {
-  return snapshot?.workspaces ?? [];
-}
-function selectPrimaryWorkspace(snapshot) {
-  const workspaces = selectWorkspaces(snapshot);
-  return workspaces.find((workspace) => workspace.sourceKind === "rig-import") ?? workspaces[0] ?? null;
-}
-function pickDefaultWorkspaceId(snapshot) {
-  return selectPrimaryWorkspace(snapshot)?.id ?? null;
-}
-function selectWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return null;
-  return snapshot?.workspaces.find((workspace) => workspace.id === workspaceId) ?? null;
-}
-function selectTask(snapshot, taskId) {
-  if (!taskId)
-    return null;
-  return snapshot?.tasks.find((task) => task.id === taskId) ?? null;
-}
-function selectTasksByWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.tasks.filter((task) => task.workspaceId === workspaceId) ?? [];
-}
-var selectTasksForWorkspace = selectTasksByWorkspace;
-function selectTasksByStatus(snapshot, status) {
-  return snapshot?.tasks.filter((task) => task.status === status) ?? [];
-}
-function projectTaskStatusForGrouping(status) {
-  switch (status) {
-    case "failed":
-      return "ready";
-    case "closed":
-      return "completed";
-    case "running":
-    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",
-  "queued",
-  "ready",
-  "open",
-  "draft",
-  "unknown",
-  "cancelled",
-  "completed"
-];
-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 = projectTaskStatusWithSessions(task, sessionsByTask);
-    const group = byStatus.get(projectedStatus);
-    if (group) {
-      group.push(task);
-    } else {
-      byStatus.set(projectedStatus, [task]);
-    }
-  }
-  const result = [];
-  for (const status of STATUS_PRIORITY) {
-    const group = byStatus.get(status);
-    if (group && group.length > 0) {
-      result.push({ status, tasks: group });
-    }
-  }
-  const overflowStatuses = Array.from(byStatus.keys()).filter((status) => !STATUS_PRIORITY.includes(status)).sort();
-  for (const status of overflowStatuses) {
-    const group = byStatus.get(status);
-    if (group && group.length > 0) {
-      result.push({ status, tasks: group });
-    }
-  }
-  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;
-  return snapshot?.runs.find((run) => run.id === runId) ?? null;
-}
-function selectRunsByTask(snapshot, taskId) {
-  if (!taskId)
-    return [];
-  return snapshot?.runs.filter((run) => run.taskId === taskId) ?? [];
-}
-var selectRunsForTask = selectRunsByTask;
-function selectRunsForWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.runs.filter((run) => run.workspaceId === workspaceId) ?? [];
-}
-function selectAdhocRuns(snapshot) {
-  return snapshot?.runs.filter((run) => run.taskId === null) ?? [];
-}
-function selectAdhocRunsForWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.runs.filter((run) => run.taskId === null && run.workspaceId === workspaceId) ?? [];
-}
-function selectGraphsForWorkspace(snapshot, workspaceId) {
-  if (!workspaceId)
-    return [];
-  return snapshot?.graphs.filter((graph) => graph.workspaceId === workspaceId) ?? [];
-}
-function selectQueueForWorkspace(snapshot, workspaceId) {
-  if (!snapshot || !workspaceId)
-    return [];
-  const taskIds = new Set(selectTasksByWorkspace(snapshot, workspaceId).map((task) => task.id));
-  return snapshot.queue.filter((entry) => taskIds.has(entry.taskId));
-}
-function selectPendingApprovals(snapshot) {
-  return snapshot?.approvals.filter((approval) => approval.status === "pending") ?? [];
-}
-function selectApprovalsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return snapshot?.approvals.filter((approval) => approval.runId === runId) ?? [];
-}
-function selectApprovalsForWorkspace(snapshot, workspaceId) {
-  if (!snapshot || !workspaceId)
-    return [];
-  const runIds = new Set(selectRunsForWorkspace(snapshot, workspaceId).map((run) => run.id));
-  return snapshot.approvals.filter((approval) => runIds.has(approval.runId));
-}
-function selectUserInputsForRun(snapshot, runId) {
-  if (!runId)
-    return [];
-  return (snapshot?.userInputs ?? []).filter((request) => request.runId === runId);
-}
-function selectUserInputsForWorkspace(snapshot, workspaceId) {
-  if (!snapshot || !workspaceId)
-    return [];
-  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 isObjectRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readStringList(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
-}
-function unique(values) {
-  return Array.from(new Set(values));
-}
-function readTaskMetadataStringList(task, key) {
-  const taskRecord = task;
-  const topLevel = readStringList(taskRecord[key]);
-  if (topLevel.length > 0)
-    return topLevel;
-  const metadata = 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) {
-  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))
-    return ref;
-  return taskIdBySourceIssueId.get(ref) ?? taskIdByExternalRef.get(ref) ?? null;
-}
-function buildTaskReferenceIndex(tasks) {
-  return {
-    tasksById: new Map(tasks.map((task) => [task.id, task])),
-    taskIdByExternalRef: new Map(tasks.flatMap((task) => task.externalId ? [[task.externalId, task.id]] : [])),
-    taskIdBySourceIssueId: new Map(tasks.flatMap((task) => {
-      const sourceIssueId = readTaskSourceIssueId(task);
-      return sourceIssueId ? [[sourceIssueId, task.id]] : [];
-    }))
-  };
-}
-function computeTaskBlockingDepths(tasks) {
-  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
-  const memo = new Map;
-  const visit = (taskId, stack) => {
-    const cached = memo.get(taskId);
-    if (cached !== undefined)
-      return cached;
-    if (stack.has(taskId))
-      return 0;
-    const task = tasksById.get(taskId);
-    if (!task)
-      return 0;
-    stack.add(taskId);
-    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
-    const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
-    stack.delete(taskId);
-    memo.set(taskId, depth);
-    return depth;
-  };
-  for (const task of tasks) {
-    visit(task.id, new Set);
-  }
-  return memo;
-}
-function isTaskTerminalStatus(status) {
-  switch (status) {
-    case "closed":
-    case "completed":
-    case "done":
-    case "cancelled":
-    case "canceled":
-      return true;
-    default:
-      return false;
-  }
-}
-function isTaskBlockedStatus(status) {
-  return status === "blocked";
-}
-function isTaskRunnableStatus(status) {
-  if (status === null || status === undefined || status === "")
-    return true;
-  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
-    return false;
-  switch (status) {
-    case "ready":
-    case "open":
-    case "failed":
-      return true;
-    default:
-      return false;
-  }
-}
-function 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) {
-  const match = title.match(TASK_CODE_RE);
-  return match?.[1] ?? null;
-}
-function extractTaskGroupKey(title) {
-  const code = extractTaskCode(title);
-  if (!code)
-    return null;
-  const parts = code.split("-");
-  const suffix = parts.at(-1) ?? "";
-  if (/^\d+$/.test(suffix)) {
-    return parts.slice(0, -1).join("-");
-  }
-  return parts[0] ?? code;
-}
-function stripTaskCode(label) {
-  return label.replace(TASK_CODE_RE, "");
-}
-// packages/core/src/taskGraphLayout.ts
-var CARD_WIDTH = 200;
-var CARD_HEIGHT = 110;
-var CELL_V_PAD = 12;
-var CELL_H_PAD = 12;
-var ROW_GAP = 28;
-var COL_GAP = 40;
-var LANE_LABEL_W = 120;
-var STAGE_HDR_H = 32;
-var PALETTE = [
-  { bg: "#3a2d12", border: "#8d6b19", edge: "#d6a11d" },
-  { bg: "#102642", border: "#245fbf", edge: "#66a2ff" },
-  { bg: "#2c173f", border: "#7b39d4", edge: "#a76df5" },
-  { bg: "#112d1c", border: "#2d8f4e", edge: "#62d882" },
-  { bg: "#3a2314", border: "#c86d1c", edge: "#e69654" },
-  { bg: "#31152b", border: "#bf3d88", edge: "#f07ebb" },
-  { bg: "#132c35", border: "#1783a6", edge: "#53c4e5" },
-  { bg: "#26310f", border: "#6d9a19", edge: "#a7da42" }
-];
-function isObjectRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readIssueType(task) {
-  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";
-}
-function findEpicAncestor(task, resolve, tasksById) {
-  const visited = new Set;
-  let current = task;
-  let epic = null;
-  while (!visited.has(current.id)) {
-    visited.add(current.id);
-    const parentRef = readTaskMetadataStringList(current, "parentChildDeps")[0];
-    if (!parentRef)
-      break;
-    const parentId = resolve(parentRef);
-    if (!parentId)
-      break;
-    const parent = tasksById.get(parentId);
-    if (!parent)
-      break;
-    if (readIssueType(parent) === "epic") {
-      epic = parent;
-    }
-    current = parent;
-  }
-  return epic;
-}
-function getRowKey(task, resolve, tasksById) {
-  const epic = findEpicAncestor(task, resolve, tasksById);
-  if (epic) {
-    return `group:${epic.id}`;
-  }
-  const codeGroup = extractTaskGroupKey(task.title);
-  if (codeGroup) {
-    return `code:${codeGroup}`;
-  }
-  return `type:${readIssueType(task) ?? "task"}`;
-}
-function getRowLabel(task, rowKey, resolve, tasksById) {
-  if (rowKey.startsWith("group:")) {
-    const groupId = rowKey.slice("group:".length);
-    return tasksById.get(groupId)?.title ?? groupId;
-  }
-  if (rowKey.startsWith("code:")) {
-    return rowKey.slice("code:".length);
-  }
-  const code = extractTaskCode(task.title);
-  if (code)
-    return code;
-  const issueType = readIssueType(task);
-  if (issueType === "task")
-    return "Tasks";
-  if (issueType)
-    return `${issueType[0]?.toUpperCase() ?? ""}${issueType.slice(1)}`;
-  const parentRef = readTaskMetadataStringList(task, "parentChildDeps")[0];
-  if (parentRef) {
-    const parentId = resolve(parentRef);
-    if (parentId) {
-      return tasksById.get(parentId)?.title ?? "Tasks";
-    }
-  }
-  return "Tasks";
-}
-function computeDepths(ids, edges) {
-  const blockers = new Map;
-  for (const edge of edges) {
-    if (!ids.has(edge.source) || !ids.has(edge.target))
-      continue;
-    const current = blockers.get(edge.target) ?? [];
-    current.push(edge.source);
-    blockers.set(edge.target, current);
-  }
-  const memo = new Map;
-  const visit = (id, stack) => {
-    const cached = memo.get(id);
-    if (cached !== undefined)
-      return cached;
-    if (stack.has(id))
-      return 0;
-    stack.add(id);
-    const deps = blockers.get(id);
-    if (!deps || deps.length === 0) {
-      memo.set(id, 0);
-      return 0;
-    }
-    let maxDepth = 0;
-    for (const dep of deps) {
-      maxDepth = Math.max(maxDepth, visit(dep, stack) + 1);
-    }
-    stack.delete(id);
-    memo.set(id, maxDepth);
-    return maxDepth;
-  };
-  for (const id of ids) {
-    visit(id, new Set);
-  }
-  return memo;
-}
-function buildTaskGraphLayout(snapshot, tasks, options) {
-  const showParentChild = options?.showParentChild ?? false;
-  const graphTasks = tasks.filter(isGraphTask);
-  if (graphTasks.length === 0) {
-    return {
-      lanes: [],
-      stages: [],
-      nodes: [],
-      edges: [],
-      totalWidth: 0,
-      totalHeight: 0,
-      taskCount: 0
-    };
-  }
-  const { tasksById, taskIdByExternalRef, taskIdBySourceIssueId } = buildTaskReferenceIndex(tasks);
-  const resolve = (ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId);
-  const rows = new Map;
-  const rowLabelByKey = new Map;
-  for (const task of graphTasks) {
-    const rowKey = getRowKey(task, resolve, tasksById);
-    const current = rows.get(rowKey) ?? [];
-    current.push(task);
-    rows.set(rowKey, current);
-    if (!rowLabelByKey.has(rowKey)) {
-      rowLabelByKey.set(rowKey, getRowLabel(task, rowKey, resolve, tasksById));
-    }
-  }
-  const orderedRows = [...rows.entries()].sort((left, right) => {
-    if (left[1].length !== right[1].length)
-      return right[1].length - left[1].length;
-    return (rowLabelByKey.get(left[0]) ?? left[0]).localeCompare(rowLabelByKey.get(right[0]) ?? right[0]);
-  });
-  const rowIndexByKey = new Map(orderedRows.map(([key], index) => [key, index]));
-  const rowIndexByTaskId = new Map;
-  for (const task of graphTasks) {
-    rowIndexByTaskId.set(task.id, rowIndexByKey.get(getRowKey(task, resolve, tasksById)) ?? 0);
-  }
-  const blockingEdgesRaw = [];
-  const depsIn = new Map;
-  const depsOut = new Map;
-  const edges = [];
-  for (const task of graphTasks) {
-    for (const ref of readTaskMetadataStringList(task, "dependencies")) {
-      const sourceId = resolve(ref);
-      if (!sourceId)
-        continue;
-      blockingEdgesRaw.push({ source: sourceId, target: task.id });
-      depsOut.set(sourceId, (depsOut.get(sourceId) ?? 0) + 1);
-      depsIn.set(task.id, (depsIn.get(task.id) ?? 0) + 1);
-      const color = PALETTE[(rowIndexByTaskId.get(sourceId) ?? 0) % PALETTE.length].edge;
-      edges.push({
-        id: `blocking:${sourceId}:${task.id}`,
-        sourceId,
-        targetId: task.id,
-        color,
-        kind: "blocking"
-      });
-    }
-    if (!showParentChild)
-      continue;
-    for (const ref of readTaskMetadataStringList(task, "parentChildDeps")) {
-      const sourceId = resolve(ref);
-      if (!sourceId)
-        continue;
-      edges.push({
-        id: `parent:${sourceId}:${task.id}`,
-        sourceId,
-        targetId: task.id,
-        color: "#5b6472",
-        kind: "parent-child"
-      });
-    }
-  }
-  const graphTaskIds = new Set(graphTasks.map((task) => task.id));
-  const depths = computeDepths(graphTaskIds, blockingEdgesRaw);
-  const maxStage = Math.max(0, ...depths.values());
-  const rowMaxStack = new Array(orderedRows.length).fill(0);
-  const cells = new Map;
-  for (const task of graphTasks) {
-    const rowIndex = rowIndexByTaskId.get(task.id) ?? 0;
-    const stage = depths.get(task.id) ?? 0;
-    const key = `${rowIndex}:${stage}`;
-    const current = cells.get(key) ?? [];
-    current.push(task);
-    cells.set(key, current);
-  }
-  for (const [cellKey, cellTasks] of cells) {
-    const [rowIndexText] = cellKey.split(":");
-    const rowIndex = Number.parseInt(rowIndexText ?? "0", 10) || 0;
-    cellTasks.sort((left, right) => {
-      const leftFanout = depsOut.get(left.id) ?? 0;
-      const rightFanout = depsOut.get(right.id) ?? 0;
-      if (leftFanout !== rightFanout)
-        return rightFanout - leftFanout;
-      return left.title.localeCompare(right.title);
-    });
-    rowMaxStack[rowIndex] = Math.max(rowMaxStack[rowIndex] ?? 0, cellTasks.length);
-  }
-  const rowHeights = rowMaxStack.map((count) => Math.max(count, 1) * (CARD_HEIGHT + CELL_V_PAD) - CELL_V_PAD + CELL_V_PAD * 2);
-  const colWidths = new Array(maxStage + 1).fill(CARD_WIDTH + CELL_H_PAD * 2);
-  const colX = [];
-  let currentX = LANE_LABEL_W;
-  for (let index = 0;index <= maxStage; index += 1) {
-    colX.push(currentX);
-    currentX += (colWidths[index] ?? 0) + COL_GAP;
-  }
-  const totalWidth = currentX - COL_GAP;
-  const rowY = [];
-  let currentY = STAGE_HDR_H;
-  for (let rowIndex = 0;rowIndex < orderedRows.length; rowIndex += 1) {
-    rowY.push(currentY);
-    currentY += (rowHeights[rowIndex] ?? 0) + ROW_GAP;
-  }
-  const totalHeight = currentY - ROW_GAP;
-  const lanes = orderedRows.map(([rowKey, rowTasks], rowIndex) => ({
-    key: rowKey,
-    label: rowLabelByKey.get(rowKey) ?? rowKey,
-    rowIndex,
-    x: LANE_LABEL_W - 6,
-    y: (rowY[rowIndex] ?? 0) - 6,
-    width: totalWidth - LANE_LABEL_W + 12,
-    height: (rowHeights[rowIndex] ?? 0) + 12,
-    color: PALETTE[rowIndex % PALETTE.length].border,
-    taskCount: rowTasks.length
-  }));
-  const stages = Array.from({ length: maxStage + 1 }, (_, index) => ({
-    index,
-    label: index === 0 ? "Roots" : `Stage ${index}`,
-    x: (colX[index] ?? 0) + CELL_H_PAD,
-    width: CARD_WIDTH
-  }));
-  const pendingApprovalRunIds = new Set(selectPendingApprovals(snapshot).map((approval) => approval.runId));
-  const nodes = [];
-  for (const [rowIndex, [rowKey]] of orderedRows.entries()) {
-    for (let stage = 0;stage <= maxStage; stage += 1) {
-      const cellTasks = cells.get(`${rowIndex}:${stage}`) ?? [];
-      const baseX = (colX[stage] ?? 0) + CELL_H_PAD;
-      const baseY = (rowY[rowIndex] ?? 0) + CELL_V_PAD;
-      const palette = PALETTE[rowIndex % PALETTE.length];
-      for (const [stackIndex, task] of cellTasks.entries()) {
-        const runs = selectRunsByTask(snapshot, task.id);
-        const runIds = new Set(runs.map((run) => run.id));
-        const hasApprovals = runs.some((run) => pendingApprovalRunIds.has(run.id));
-        const hasPendingUserInput = runs.some((run) => selectUserInputsForRun(snapshot, run.id).some((request) => request.status === "pending"));
-        const hasRejectedReview = (snapshot?.reviews ?? []).some((review) => runIds.has(review.runId) && review.status === "rejected");
-        const hasFailedValidations = (snapshot?.validations ?? []).some((validation) => runIds.has(validation.runId) && validation.status === "failed");
-        const artifactCount = (snapshot?.artifacts ?? []).filter((artifact) => runIds.has(artifact.runId)).length;
-        nodes.push({
-          id: task.id,
-          taskId: task.id,
-          task,
-          rowKey,
-          rowLabel: rowLabelByKey.get(rowKey) ?? rowKey,
-          rowIndex,
-          stage,
-          x: baseX,
-          y: baseY + stackIndex * (CARD_HEIGHT + CELL_V_PAD),
-          width: CARD_WIDTH,
-          height: CARD_HEIGHT,
-          color: palette.border,
-          taskCode: extractTaskCode(task.title),
-          strippedTitle: stripTaskCode(task.title),
-          depsIn: depsIn.get(task.id) ?? 0,
-          depsOut: depsOut.get(task.id) ?? 0,
-          runCount: runs.length,
-          hasApprovals,
-          hasPendingUserInput,
-          hasRejectedReview,
-          hasFailedValidations,
-          artifactCount
-        });
-      }
-    }
-  }
-  return {
-    lanes,
-    stages,
-    nodes,
-    edges,
-    totalWidth,
-    totalHeight,
-    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";
 export {
-  stripTaskCode,
-  selectWorkspaces,
-  selectWorkspace,
-  selectUserInputsForWorkspace,
-  selectUserInputsForRun,
-  selectTasksGroupedByStatus,
-  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,
-  PipelineUnresolvableError
+  RIG_CORE_PACKAGE
 };