@h-rig/core 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/index.js

@@ -1,69 +1,42 @@
 // @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`);
-      }
-    }
-  }
-  return { ...validated, __runtime: 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";
 import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
 function defineConfig(cfg) {
-  const runtimeByName = new Map;
-  const plugins = cfg.plugins ?? [];
-  for (const plugin of plugins) {
-    if (plugin?.__runtime) {
-      runtimeByName.set(plugin.name, plugin.__runtime);
-    }
-  }
-  const decoded = Schema2.decodeUnknownSync(RigConfig)(cfg);
-  const decodedPlugins = decoded.plugins.map((p) => {
-    const runtime = runtimeByName.get(p.name);
-    if (!runtime)
-      return p;
-    return { ...p, __runtime: runtime };
+  const withDefaults = applyConfigDefaults(cfg);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig)({
+    ...withDefaults,
+    plugins: explicitPlugins
   });
-  return { ...decoded, plugins: decodedPlugins };
+  return { ...decoded, plugins: explicitPlugins };
 }
 // packages/core/src/plugin-host.ts
 function indexById(contributions, kind) {
@@ -87,49 +60,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.__runtime?.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.__runtime?.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.__runtime?.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.__runtime?.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`);
-      }
-    }
-  }
-}
 function createPluginHost(plugins) {
   assertUniquePluginNames(plugins);
-  for (const plugin of plugins) {
-    assertRuntimeMatchesMetadata(plugin);
-  }
   const validators = [];
   const hooks = [];
   const skills = [];
@@ -138,19 +70,19 @@ function createPluginHost(plugins) {
   const taskFieldExtensions = [];
   const taskSources = [];
   const cliCommands = [];
-  const executableValidators = [];
-  const executableTaskSources = [];
+  const capabilities = [];
+  const panels = [];
+  const blockerClassifiers = [];
+  const sessionExtensions = [];
+  const seedEntrypoints = [];
+  const stages = [];
+  const stageMutations = [];
+  const stageExecutors = {};
   for (const plugin of plugins) {
     const c = plugin.contributes;
     if (!c)
       continue;
     const pluginName = plugin.name;
-    if (plugin.__runtime?.validators) {
-      executableValidators.push(...plugin.__runtime.validators.map((item) => ({ item, pluginName })));
-    }
-    if (plugin.__runtime?.taskSources) {
-      executableTaskSources.push(...plugin.__runtime.taskSources.map((item) => ({ item, pluginName })));
-    }
     if (c.validators)
       validators.push(...c.validators.map((item) => ({ item, pluginName })));
     if (c.hooks)
@@ -167,17 +99,25 @@ function createPluginHost(plugins) {
       taskSources.push(...c.taskSources.map((item) => ({ item, pluginName })));
     if (c.cliCommands)
       cliCommands.push(...c.cliCommands.map((item) => ({ item, pluginName })));
-  }
-  indexById(executableValidators, "executableValidator");
-  indexById(executableTaskSources, "executableTaskSource");
-  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.capabilities)
+      capabilities.push(...c.capabilities.map((item) => ({ item, pluginName })));
+    if (c.panels)
+      panels.push(...c.panels.map((item) => ({ item, pluginName })));
+    if (c.blockerClassifiers)
+      blockerClassifiers.push(...c.blockerClassifiers.map((item) => ({ item, pluginName })));
+    if (c.sessionExtensions)
+      sessionExtensions.push(...c.sessionExtensions.map((item) => ({ item, pluginName })));
+    if (c.seedEntrypoints)
+      seedEntrypoints.push(...c.seedEntrypoints.map((item) => ({ item, pluginName })));
+    if (c.stageMutations)
+      stageMutations.push(...c.stageMutations.map((item) => ({ item, 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");
@@ -187,6 +127,52 @@ function createPluginHost(plugins) {
   const taskFieldExtMap = indexById(taskFieldExtensions, "taskFieldExtension");
   const taskSourceMap = indexById(taskSources, "taskSource");
   const cliCommandMap = indexById(cliCommands, "cliCommand");
+  const capabilityMap = indexById(capabilities, "capability");
+  const panelMap = indexById(panels, "panel");
+  const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
+  indexById(sessionExtensions, "sessionExtension");
+  indexById(seedEntrypoints, "seedEntrypoint");
+  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 seedEntrypointByBasename = new Map;
+  const seedEntrypointByWorkerArg = new Map;
+  let insidePtySeedEntrypoint;
+  const registerSeedEntrypointSelector = (map, selectorKind, selector, contribution) => {
+    const existing = map.get(selector);
+    if (existing) {
+      throw new Error(`duplicate seed entrypoint ${selectorKind} "${selector}": registered by entrypoint "${existing.item.id}" from plugin "${existing.pluginName}" and entrypoint "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    map.set(selector, contribution);
+  };
+  for (const contribution of seedEntrypoints) {
+    const entrypoint = contribution.item;
+    let selectorCount = 0;
+    if (entrypoint.basename) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByBasename, "basename", entrypoint.basename, contribution);
+    }
+    if (entrypoint.workerArg) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByWorkerArg, "workerArg", entrypoint.workerArg, contribution);
+    }
+    if (entrypoint.insidePty) {
+      selectorCount += 1;
+      if (insidePtySeedEntrypoint) {
+        throw new Error(`duplicate seed entrypoint inside-pty selector: registered by entrypoint "${insidePtySeedEntrypoint.item.id}" from plugin "${insidePtySeedEntrypoint.pluginName}" and entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}"`);
+      }
+      insidePtySeedEntrypoint = contribution;
+    }
+    if (selectorCount === 0) {
+      throw new Error(`seed entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}" must declare at least one selector (basename, workerArg, or insidePty)`);
+    }
+  }
   const allValidators = validators.map((c) => c.item);
   const allHooks = hooks.map((c) => c.item);
   const allSkills = skills.map((c) => c.item);
@@ -195,8 +181,39 @@ function createPluginHost(plugins) {
   const allTaskFieldExtensions = taskFieldExtensions.map((c) => c.item);
   const allTaskSources = taskSources.map((c) => c.item);
   const allCliCommands = cliCommands.map((c) => c.item);
-  const allExecutableValidators = executableValidators.map((c) => c.item);
-  const allExecutableTaskSources = executableTaskSources.map((c) => c.item);
+  const allStageMutations = stageMutations.map((c) => c.item);
+  const allStages = stages.map((c) => c.item);
+  const allCapabilities = capabilities.map((c) => c.item);
+  const allPanels = panels.map((c) => c.item);
+  const allBlockerClassifiers = blockerClassifiers.map((c) => c.item);
+  const allSessionExtensions = sessionExtensions.map((c) => c.item);
+  const allSeedEntrypoints = seedEntrypoints.map((c) => c.item);
+  const executableCliCommandByName = new Map;
+  const registerExecutableCliCommandSelector = (selector, contribution) => {
+    const existing = executableCliCommandByName.get(selector);
+    if (existing && existing.item.id !== contribution.item.id) {
+      throw new Error(`duplicate executable CLI selector "${selector}" registered by command "${existing.item.id}" from plugin "${existing.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    executableCliCommandByName.set(selector, contribution);
+  };
+  for (const contribution of cliCommands) {
+    const command = contribution.item;
+    const family = command.family ?? command.id;
+    registerExecutableCliCommandSelector(command.id, contribution);
+    registerExecutableCliCommandSelector(family, contribution);
+    for (const alias of command.aliases ?? []) {
+      registerExecutableCliCommandSelector(alias, contribution);
+    }
+  }
+  let defaultRootCliCommand;
+  for (const contribution of cliCommands) {
+    if (!contribution.item.rootDefault)
+      continue;
+    if (defaultRootCliCommand) {
+      throw new Error(`duplicate default root CLI command registered by command "${defaultRootCliCommand.item.id}" from plugin "${defaultRootCliCommand.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    defaultRootCliCommand = contribution;
+  }
   return {
     getValidator: (id) => validatorMap.get(id),
     getHook: (id) => hookMap.get(id),
@@ -206,6 +223,9 @@ function createPluginHost(plugins) {
     getTaskFieldExtension: (id) => taskFieldExtMap.get(id),
     getTaskSource: (id) => taskSourceMap.get(id),
     getCliCommand: (id) => cliCommandMap.get(id),
+    getCapability: (id) => capabilityMap.get(id),
+    getPanel: (id) => panelMap.get(id),
+    getBlockerClassifier: (id) => blockerClassifierMap.get(id),
     listValidators: () => allValidators,
     listHooks: () => allHooks,
     listSkills: () => allSkills,
@@ -214,2403 +234,94 @@ function createPluginHost(plugins) {
     listTaskFieldExtensions: () => allTaskFieldExtensions,
     listTaskSources: () => allTaskSources,
     listCliCommands: () => allCliCommands,
-    listExecutableValidators: () => allExecutableValidators,
-    listExecutableTaskSources: () => allExecutableTaskSources,
+    listCapabilities: () => allCapabilities,
+    listPanels: () => allPanels,
+    listBlockerClassifiers: () => allBlockerClassifiers,
+    listStages: () => allStages,
+    listStageMutations: () => allStageMutations,
+    listStageExecutors: () => stageExecutors,
+    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,
+    listSeedEntrypoints: () => allSeedEntrypoints,
+    resolveSeedEntrypointByBasename: (value) => seedEntrypointByBasename.get(value)?.item,
+    resolveSeedEntrypointByWorkerArg: (value) => seedEntrypointByWorkerArg.get(value)?.item,
+    resolveInsidePtySeedEntrypoint: () => insidePtySeedEntrypoint?.item,
+    resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
+    resolveDefaultRootCliCommand: () => defaultRootCliCommand?.item,
     resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
   };
 }
-// packages/core/src/rig-init-builder.ts
-function buildRigInitConfigSource(input) {
-  const lines = [`import { defineConfig } from "@rig/core";`];
-  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`import standard, { createStateGitHubCredentialProvider } from "@rig/standard-plugin";`);
-  } else if (input.useStandardPlugin) {
-    lines.push(`import standard from "@rig/standard-plugin";`);
-  }
-  lines.push(``, `export default defineConfig({`);
-  const projectRepo = input.projectRepo ?? (input.taskSource.kind === "github-issues" ? `${input.taskSource.owner}/${input.taskSource.repo}` : undefined);
-  lines.push(projectRepo ? `  project: { name: ${JSON.stringify(input.projectName)}, repo: ${JSON.stringify(projectRepo)} },` : `  project: { name: ${JSON.stringify(input.projectName)} },`);
-  if (input.useStandardPlugin && input.taskSource.kind === "github-issues") {
-    lines.push(`  plugins: [standard({`);
-    lines.push(`    githubCredentialProvider: createStateGitHubCredentialProvider(),`);
-    lines.push(`    githubWorkspaceId: ${JSON.stringify(`${input.taskSource.owner}/${input.taskSource.repo}`)},`);
-    lines.push(`    githubUserId: process.env.RIG_GITHUB_USER_ID ?? "server-selected-user",`);
-    lines.push(`  })],`);
-  } else {
-    lines.push(`  plugins: [${input.useStandardPlugin ? "standard()" : ""}],`);
-  }
-  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" },`);
-  lines.push(`  runtime: { harness: "pi", mode: "yolo" },`);
-  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";
-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 "cancelled";
-    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":
-      return "under_review";
-    case "completed":
-      return "completed";
-    case "failed":
-      return "ready";
-    case "cancelled":
-      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: "rig-native",
-    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: "rig-native",
-    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: "rig-native",
-    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: "codex-app-server",
-      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: "codex-app-server",
-      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: providerName ?? existingRun.runtimeAdapter,
-      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: providerName ?? existingRun.runtimeAdapter,
-      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: payload.runtimeAdapter,
-        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: "cancelled",
-            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: "rig-native",
-      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: "rig-native",
-      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;
-    }
+// packages/core/src/capability.ts
+import { resolveCapability } from "@rig/kernel-seed";
+
+class CapabilityProviderMissingError extends Error {
+  capabilityId;
+  name = "CapabilityProviderMissingError";
+  constructor(capabilityId) {
+    super(`No provider resolved for capability "${capabilityId}"`);
+    this.capabilityId = capabilityId;
+  }
+}
+function isFactory(impl) {
+  return typeof impl === "function";
+}
+function defineCapability(id) {
+  const idString = String(id);
+  const tag = idString;
+  async function resolve(host) {
+    const providers = host.listExecutableCapabilities().filter((c) => c.id === idString && typeof c.run === "function").map((c) => ({
+      name: c.id,
+      provides: [c.id],
+      capabilityProviders: { [c.id]: c.run }
+    }));
+    const resolution = resolveCapability(providers, tag);
+    const run = resolution?.value;
+    if (!run)
+      return null;
+    return await run(undefined);
   }
   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";
-    default:
-      return status;
-  }
-}
-var STATUS_PRIORITY = [
-  "running",
-  "blocked",
-  "queued",
-  "ready",
-  "open",
-  "draft",
-  "unknown",
-  "cancelled",
-  "completed"
-];
-function selectTasksGroupedByStatus(snapshot, workspaceId) {
-  const tasks = selectTasksByWorkspace(snapshot, workspaceId);
-  const byStatus = new Map;
-  for (const task of tasks) {
-    const projectedStatus = projectTaskStatusForGrouping(task.status);
-    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 });
+    id,
+    provide(impl, opts) {
+      return {
+        id: idString,
+        title: opts?.title ?? idString,
+        ...opts?.description !== undefined ? { description: opts.description } : {},
+        run: isFactory(impl) ? () => impl() : () => impl
+      };
+    },
+    resolve,
+    async require(host) {
+      const value = await resolve(host);
+      if (value === null)
+        throw new CapabilityProviderMissingError(idString);
+      return value;
     }
-  }
-  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 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/taskGraph.ts
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readTaskMetadataStringList(task, key) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const value = metadata?.[key];
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
-}
-function readTaskSourceIssueId(task) {
-  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : null;
-}
-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 refs = [
-      ...readTaskMetadataStringList(task, "dependencies"),
-      ...readTaskMetadataStringList(task, "parentChildDeps")
-    ];
-    const blockers = refs.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;
-}
-// 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 isObjectRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readIssueType(task) {
-  const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
-  return typeof metadata?.issueType === "string" ? metadata.issueType : null;
-}
-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,
-          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
-        });
-      }
-    }
-  }
+function defineServiceCapability(id) {
+  const capability = defineCapability(id);
   return {
-    lanes,
-    stages,
-    nodes,
-    edges,
-    totalWidth,
-    totalHeight,
-    taskCount: graphTasks.length
+    ...capability,
+    provideService: capability.provide,
+    resolveService: capability.resolve,
+    requireService: capability.require
   };
 }
 
 // packages/core/src/index.ts
 var RIG_CORE_PACKAGE = "@rig/core";
 export {
-  stripTaskCode,
-  selectWorkspaces,
-  selectWorkspace,
-  selectUserInputsForWorkspace,
-  selectUserInputsForRun,
-  selectTasksGroupedByStatus,
-  selectTasksForWorkspace,
-  selectTasksByWorkspace,
-  selectTasksByStatus,
-  selectTask,
-  selectRunsForWorkspace,
-  selectRunsForTask,
-  selectRunsByTask,
-  selectRun,
-  selectQueueForWorkspace,
-  selectPrimaryWorkspace,
-  selectPendingApprovals,
-  selectGraphsForWorkspace,
-  selectApprovalsForWorkspace,
-  selectApprovalsForRun,
-  selectAdhocRunsForWorkspace,
-  selectAdhocRuns,
-  resolveTaskReference,
-  readTaskSourceIssueId,
-  readTaskMetadataStringList,
-  pruneQueueEntries,
-  pickDefaultWorkspaceId,
-  extractTaskGroupKey,
-  extractTaskCode,
+  defineServiceCapability,
   definePlugin,
   defineConfig,
+  defineCapability,
   createPluginHost,
-  computeTaskBlockingDepths,
-  buildTaskReferenceIndex,
-  buildTaskGraphLayout,
-  buildRigInitConfigSource,
-  applyEngineEvent as applyRigEvent,
-  applyEngineEvents,
-  applyEngineEvent,
-  RIG_CORE_PACKAGE
+  RIG_CORE_PACKAGE,
+  CapabilityProviderMissingError
 };