@h-rig/core 0.0.6-alpha.0

package/dist/src/index.js

@@ -0,0 +1,2616 @@
+// @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 };
+}
+// packages/core/src/define-config.ts
+import { Schema as Schema2 } from "effect";
+import { RigConfig } from "@rig/contracts";
+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 };
+  });
+  return { ...decoded, plugins: decodedPlugins };
+}
+// packages/core/src/plugin-host.ts
+function indexById(contributions, kind) {
+  const map = new Map;
+  const registrant = new Map;
+  for (const { item, pluginName } of contributions) {
+    if (map.has(item.id)) {
+      throw new Error(`duplicate ${kind} id "${item.id}": registered by plugins "${registrant.get(item.id)}" and "${pluginName}"`);
+    }
+    map.set(item.id, item);
+    registrant.set(item.id, pluginName);
+  }
+  return map;
+}
+function assertUniquePluginNames(plugins) {
+  const seen = new Set;
+  for (const plugin of plugins) {
+    if (seen.has(plugin.name)) {
+      throw new Error(`duplicate plugin name "${plugin.name}"`);
+    }
+    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 = [];
+  const repoSources = [];
+  const agentRoles = [];
+  const taskFieldExtensions = [];
+  const taskSources = [];
+  const cliCommands = [];
+  const executableValidators = [];
+  const executableTaskSources = [];
+  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)
+      hooks.push(...c.hooks.map((item) => ({ item, pluginName })));
+    if (c.skills)
+      skills.push(...c.skills.map((item) => ({ item, pluginName })));
+    if (c.repoSources)
+      repoSources.push(...c.repoSources.map((item) => ({ item, pluginName })));
+    if (c.agentRoles)
+      agentRoles.push(...c.agentRoles.map((item) => ({ item, pluginName })));
+    if (c.taskFieldSchemas)
+      taskFieldExtensions.push(...c.taskFieldSchemas.map((item) => ({ item, pluginName })));
+    if (c.taskSources)
+      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}"`);
+    }
+    taskSourceFactoryByKind.set(item.kind, item);
+    taskSourceKindRegistrant.set(item.kind, pluginName);
+  }
+  const validatorMap = indexById(validators, "validator");
+  const hookMap = indexById(hooks, "hook");
+  const skillMap = indexById(skills, "skill");
+  const repoSourceMap = indexById(repoSources, "repoSource");
+  const agentRoleMap = indexById(agentRoles, "agentRole");
+  const taskFieldExtMap = indexById(taskFieldExtensions, "taskFieldExtension");
+  const taskSourceMap = indexById(taskSources, "taskSource");
+  const cliCommandMap = indexById(cliCommands, "cliCommand");
+  const allValidators = validators.map((c) => c.item);
+  const allHooks = hooks.map((c) => c.item);
+  const allSkills = skills.map((c) => c.item);
+  const allRepoSources = repoSources.map((c) => c.item);
+  const allAgentRoles = agentRoles.map((c) => c.item);
+  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);
+  return {
+    getValidator: (id) => validatorMap.get(id),
+    getHook: (id) => hookMap.get(id),
+    getSkill: (id) => skillMap.get(id),
+    getRepoSource: (id) => repoSourceMap.get(id),
+    getAgentRole: (id) => agentRoleMap.get(id),
+    getTaskFieldExtension: (id) => taskFieldExtMap.get(id),
+    getTaskSource: (id) => taskSourceMap.get(id),
+    getCliCommand: (id) => cliCommandMap.get(id),
+    listValidators: () => allValidators,
+    listHooks: () => allHooks,
+    listSkills: () => allSkills,
+    listRepoSources: () => allRepoSources,
+    listAgentRoles: () => allAgentRoles,
+    listTaskFieldExtensions: () => allTaskFieldExtensions,
+    listTaskSources: () => allTaskSources,
+    listCliCommands: () => allCliCommands,
+    listExecutableValidators: () => allExecutableValidators,
+    listExecutableTaskSources: () => allExecutableTaskSources,
+    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: 30 },`);
+  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;
+    }
+  }
+  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 });
+    }
+  }
+  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
+        });
+      }
+    }
+  }
+  return {
+    lanes,
+    stages,
+    nodes,
+    edges,
+    totalWidth,
+    totalHeight,
+    taskCount: graphTasks.length
+  };
+}
+
+// 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,
+  definePlugin,
+  defineConfig,
+  createPluginHost,
+  computeTaskBlockingDepths,
+  buildTaskReferenceIndex,
+  buildTaskGraphLayout,
+  buildRigInitConfigSource,
+  applyEngineEvent as applyRigEvent,
+  applyEngineEvents,
+  applyEngineEvent,
+  RIG_CORE_PACKAGE
+};