@h-rig/core 0.0.6-alpha.0

package/dist/src/engineReadModelReducer.js

@@ -0,0 +1,1780 @@
+// @bun
+// 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";
+  });
+}
+export {
+  pruneQueueEntries,
+  mapTaskStatusFromRunStatus,
+  applyEngineEvents,
+  applyEngineEvent
+};