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

package/dist/src/engineReadModelReducer.js

@@ -1,1780 +0,0 @@
-// @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
-};