@cursor/july 0.1.107 → 0.1.109

package/src/internal/session-engine.ts

@@ -12,12 +12,6 @@ import { mkdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import type { SDKCustomTool, SDKCustomToolResult } from "@cursor/sdk";
 import type { Meter } from "@opentelemetry/api";
-import {
-  type ABDefinition,
-  mergeABInstructions,
-  resolveABMaxPlaygroundSessions,
-  resolveABSplit,
-} from "../ab.js";
 import { SLACK_CHANNEL_ID } from "../channels/slack/constants.js";
 import { materializeSlackNudgeCarrier } from "../channels/slack/nudge-carrier.js";
 import {
@@ -98,9 +92,6 @@ import {
   type ToolNeedsApproval,
   type TurnOutcome,
 } from "../types.js";
-import { ABCollector } from "./ab-collector.js";
-import { foldABStream } from "./ab-fold.js";
-import { type ABSnapshot, buildABSnapshot } from "./ab-snapshot.js";
 import {
   type AdvertiseHostMcp,
   resolveAdvertisedTools,
@@ -114,6 +105,10 @@ import {
   sessionClock,
 } from "./as-of.js";
 import { SessionAuthError, samePrincipal } from "./auth.js";
+import {
+  mergeChannelStateMutation,
+  mergeChannelStateSkipNull,
+} from "./channel-state.js";
 import { mergeCloudOptions, resolveSessionRuntime } from "./cloud-merge.js";
 import {
   applyCloudUsageToEvents,
@@ -132,7 +127,7 @@ import {
   resolveV2Key,
   V2EngineError,
 } from "./continuation-identity.js";
-import { describeError } from "./describe-error.js";
+import { describeError, describeErrorCode } from "./describe-error.js";
 import { isDevMode } from "./dev-mode.js";
 import { type EventLogMemoryStats, EventLogStore } from "./event-log.js";
 import { TurnEventMapper } from "./event-mapper.js";
@@ -160,6 +155,7 @@ import {
   HostedAdmissionLocalSendError,
   isDuringHostedAdmission,
 } from "./hosted-admission-context.js";
+import { hostedSessionResumeKey } from "./hosted-catch-protocol.js";
 import {
   formatContinuationToken,
   newContinuationKey,
@@ -217,11 +213,17 @@ import {
 } from "./workspace-sync.js";
 
 export const HTTP_CHANNEL_ID = "http";
+export { mergeChannelStateSkipNull } from "./channel-state.js";
 export { SCHEDULE_CHANNEL_PREFIX } from "./prompt-context.js";
 
 /** Authored surfaces mirrored onto the Agent Store before a first cloud prompt. */
 type CloudSyncSurface = "skills" | "workspace";
 
+interface EventDispatchContext {
+  channelState: JsonValue;
+  session: SessionInfo;
+}
+
 /** The Agent Store cloud turns read authored files from, and where the VM mounts it. */
 interface CloudStoreTarget {
   sink: FileSink;
@@ -444,8 +446,8 @@ export class SessionEngine {
   /**
    * Runtime for `agent/storage.ts` (`defineStorage`), when
    * authored. All durable state changes funnel through it (session
-   * records, event chunks, A/B samples/snapshots); the eval run store
-   * attaches via {@link StorageCoordinator.evalRuns} at serve start.
+   * records, event chunks); the eval run store attaches via
+   * {@link StorageCoordinator.evalRuns} at serve start.
    */
   readonly storage: StorageCoordinator | undefined;
   /** In-flight lazy restores, deduped per channel + continuation key. */
@@ -453,8 +455,6 @@ export class SessionEngine {
     string,
     Promise<SessionRecord | undefined>
   >();
-  /** Once-per-process cache for the A/B snapshot backfill (see abSnapshot). */
-  private restoredAbSnapshot: Promise<ABSnapshot | undefined> | undefined;
   /** In-flight authored files → Agent Store syncs (see syncToCloudStore). */
   private readonly cloudSyncs = new Map<CloudSyncSurface, Promise<boolean>>();
 
@@ -517,7 +517,6 @@ export class SessionEngine {
   private probeCursorAccount:
     | ((connection: string) => Promise<string | undefined>)
     | undefined;
-  private readonly abCollector: ABCollector;
   private readonly otel: OtelCollector | undefined;
   private readonly otelHost: HostOtelSessionApi;
   private readonly stopMemoryTelemetry: (() => void) | undefined;
@@ -628,13 +627,6 @@ export class SessionEngine {
       config: options.project.artifacts,
       sink: managedV2Files?.(),
     });
-    this.abCollector = new ABCollector(
-      options.project.abs,
-      this.logger,
-      async (sessionId) => (await this.logs.get(sessionId)).snapshot(0),
-      // Samples flow to the defineStorage `abs` table (no-op without one).
-      { persistSample: (sample) => this.storage?.abSample(sample) }
-    );
     // Peer and Cursor-account transports are symbolic until the serve host
     // resolves them; the host-side MCP registry starts with the concrete
     // connections and gains the rest via setResolvedConnections.
@@ -1019,6 +1011,18 @@ export class SessionEngine {
         sendOptions.continuationToken
       );
     }
+    if (
+      existing === undefined &&
+      sendOptions.hostedSessionId !== undefined &&
+      sendOptions.mailboxContinuation?.key ===
+        hostedSessionResumeKey(sendOptions.hostedSessionId)
+    ) {
+      // Explicit control-plane resume of an existing session: the CP named
+      // the session by its own id and stamped the matching resume key. The
+      // session keeps its original continuation key (a PR lane must stay
+      // addressable by its webhooks); this is a follow-up turn by id.
+      existing = await this.getOrRestoreSession(sendOptions.hostedSessionId);
+    }
 
     if (existing !== undefined) {
       if (
@@ -1115,7 +1119,7 @@ export class SessionEngine {
     const purpose = sendOptions.purpose === "eval" ? "eval" : "live";
     const frozenAsOf = normalizeAsOf(sendOptions.asOf);
     assertTimeArgs(this.project.agent.tools, frozenAsOf);
-    let record: SessionRecord = {
+    const record: SessionRecord = {
       sessionId: sendOptions.hostedSessionId ?? newSessionId(),
       channelId,
       mode: sendOptions.mode ?? "chat",
@@ -1144,7 +1148,6 @@ export class SessionEngine {
         dryRun: record.dryRun === true ? true : undefined,
       },
     });
-    record = await this.enrollABs(record);
     const since = (await this.logs.get(record.sessionId)).count;
     await this.startTurn(record.sessionId, message, {
       admission: sendOptions.admission ?? "preempt",
@@ -1218,97 +1221,6 @@ export class SessionEngine {
     return existing !== undefined;
   }
 
-  /**
-   * Sticky A/B enrollment at session creation — before the first turn, so
-   * variants are in the durable stream (and on {@link SessionRecord.abs})
-   * ahead of model/instructions work. Failures persist as `variant: null`
-   * (sticky skip). Eval harness sessions (`purpose: "eval"`) are never
-   * enrolled.
-   */
-  private async enrollABs(record: SessionRecord): Promise<SessionRecord> {
-    if (!this.abCollector.enabled || record.purpose === "eval") {
-      return record;
-    }
-    const sessionInfo = this.sessionInfo(record);
-    const abs: Record<string, string | null> = {};
-    for (const experiment of this.project.abs) {
-      const def = experiment.definition as ABDefinition;
-      const variantKeys = Object.keys(def.variants);
-      let variant: string | null = null;
-      try {
-        variant = await resolveABSplit(def.split, {
-          agent: { name: this.project.name },
-          channel: { id: record.channelId },
-          session: sessionInfo,
-          experiment: experiment.name,
-          variants: variantKeys,
-        });
-        if (variant !== null && !(variant in def.variants)) {
-          throw new Error(
-            `split resolved to ${JSON.stringify(variant)}; expected one of ${variantKeys.join(", ")} or null to skip`
-          );
-        }
-      } catch (error) {
-        this.logger(
-          `[agent-sdk] ab "${experiment.name}" enrollment failed (sticky skip): ${describeError(error)}`
-        );
-        variant = null;
-      }
-      abs[experiment.name] = variant;
-      await this.appendEvent(record.sessionId, {
-        type: "ab.assigned",
-        data: { experiment: experiment.name, variant },
-      });
-    }
-    return this.updateRecord(record.sessionId, (current) => ({
-      ...current,
-      abs,
-    }));
-  }
-
-  /**
-   * Ensure {@link SessionRecord.abs} is populated (hydrate from the durable
-   * `ab.assigned` stream when missing — e.g. older sessions after upgrade).
-   */
-  private async ensureAbs(record: SessionRecord): Promise<SessionRecord> {
-    if (record.abs !== undefined || record.purpose === "eval") {
-      return record;
-    }
-    if (!this.abCollector.enabled) {
-      return record;
-    }
-    const events = await this.listEvents(record.sessionId, 0);
-    const folded = foldABStream(events);
-    if (folded.arms.size === 0) {
-      return record;
-    }
-    const abs = Object.fromEntries(folded.arms);
-    return this.updateRecord(record.sessionId, (current) => ({
-      ...current,
-      abs,
-    }));
-  }
-
-  /**
-   * Agent config for this session: base project agent plus any per-variant
-   * `instructions` overlays from enrolled A/B arms.
-   */
-  private agentForSession(record: SessionRecord): ResolvedAgent {
-    const base = this.project.agent;
-    const instructions = mergeABInstructions(
-      base.instructions,
-      record.abs,
-      this.project.abs.map((experiment) => ({
-        name: experiment.name,
-        definition: experiment.definition as ABDefinition,
-      }))
-    );
-    if (instructions === base.instructions) {
-      return base;
-    }
-    return { ...base, instructions };
-  }
-
   /** Look up a session as a channel-scoped handle. */
   async getChannelSession(
     channelId: string,
@@ -1633,12 +1545,10 @@ export class SessionEngine {
 
     let lifecycleInstalled = false;
     try {
-      let record = await this.updateRecord(sessionId, (current) => ({
+      const record = await this.updateRecord(sessionId, (current) => ({
         ...current,
         turnCount: current.turnCount + 1,
       }));
-      // Arms must be on the record before tools/instructions see SessionInfo.
-      record = await this.ensureAbs(record);
       const turnId = `turn_${record.turnCount}`;
       const isFirstTurn = record.turnCount === 1;
 
@@ -1668,10 +1578,16 @@ export class SessionEngine {
             isFirstTurn,
             abort.signal
           );
+          if (outcome.status === "cancelled") {
+            outcome.cancellationReason = abort.signal.aborted
+              ? "signal"
+              : "runner";
+          }
         } catch (error) {
           outcome = {
             status: "error",
             errorMessage: describeError(error),
+            errorCode: describeErrorCode(error),
           };
         } finally {
           clearInterval(poll);
@@ -2192,6 +2108,11 @@ export class SessionEngine {
     const sessionId = record.sessionId;
     const workspaceDir = this.scaffoldDir(record);
     const harnessCwd = this.harnessCwd(record);
+    const turnChannelState = structuredClone(record.channelState ?? null);
+    const eventContext: EventDispatchContext = {
+      channelState: structuredClone(turnChannelState),
+      session: this.sessionInfo(record),
+    };
     // Hold the open log so tool events append synchronously. Fire-and-forget
     // `appendEvent` races parallel tool completions and delays the live stream
     // until the next await tick — often after *all* parallel tools finish.
@@ -2199,7 +2120,7 @@ export class SessionEngine {
     const emit = (payload: SessionEventPayload): void => {
       try {
         const event = log.append({ ...payload, turnId });
-        this.queueDispatch(sessionId, event);
+        this.queueDispatch(sessionId, event, eventContext);
       } catch (error) {
         this.logger(
           `[agent-sdk] failed to record event for ${sessionId}: ${describeError(error)}`
@@ -2235,12 +2156,10 @@ export class SessionEngine {
       emit({ type: "turn.started", data: {} });
       try {
         // Scaffold agent files into the session workspace even when the harness
-        // cwd is overridden (e.g. a PR worktree). A/B variant instruction
-        // overlays are applied via agentForSession.
-        const agent = this.agentForSession(record);
+        // cwd is overridden (e.g. a PR worktree).
         if (!this.hasRootOverride()) {
           await materializeWorkspace({
-            agent,
+            agent: this.project.agent,
             workspaceDir,
             seed: isFirstTurn,
             stateRoot: this.stateRoot,
@@ -2262,7 +2181,7 @@ export class SessionEngine {
         const pendingFiles = record.pendingWorkspaceFiles;
         const pendingImages = record.pendingImages;
         const runtime = resolveSessionRuntime({
-          agentRuntime: agent.runtime,
+          agentRuntime: this.project.agent.runtime,
           cloudOverride: record.cloudOverride,
         });
         const hasPendingFiles =
@@ -2305,12 +2224,12 @@ export class SessionEngine {
             (await isNestedInGitRepo(harnessCwd)));
         const request = await this.buildTurnRequest(
           record,
-          agent,
           turnId,
           message,
           isFirstTurn,
           instructionsInvisibleToHarness,
           emit,
+          eventContext,
           async (update) => {
             const turn = this.turnRoots.get(sessionId);
             if (turn !== undefined) {
@@ -2352,7 +2271,11 @@ export class SessionEngine {
       } catch (error) {
         this.approvals.cancelSession(sessionId, "deny");
         this.auths.cancelSession(sessionId, "deny");
-        outcome = { status: "error", errorMessage: describeError(error) };
+        outcome = {
+          status: "error",
+          errorMessage: describeError(error),
+          errorCode: describeErrorCode(error),
+        };
       } finally {
         permit.release();
         this.dropTurnFileSystem(sessionId);
@@ -2371,6 +2294,7 @@ export class SessionEngine {
     if (mapper.title !== undefined) {
       const title = mapper.title;
       await this.updateRecord(sessionId, (current) => ({ ...current, title }));
+      eventContext.session = { ...eventContext.session, title };
     }
 
     const finalResult = outcome.result ?? mapper.finalText;
@@ -2395,7 +2319,8 @@ export class SessionEngine {
         text: finalResult,
         dryRun: record.dryRun === true,
         ctx: {
-          session: this.sessionInfo(record),
+          session: eventContext.session,
+          channelState: turnChannelState,
           host: this.hostForSession(sessionId),
           artifacts: this.artifactsApi({ sessionId, turnId }),
           stateRoot: this.stateRoot,
@@ -2414,29 +2339,38 @@ export class SessionEngine {
     }
 
     if (outcome.status === "finished") {
-      await this.appendEvent(sessionId, {
-        type: "turn.completed",
-        turnId,
-        data: {
-          result: finalResult,
-          usage: finalUsage,
-          cost: finalCost,
+      await this.appendEvent(
+        sessionId,
+        {
+          type: "turn.completed",
+          turnId,
+          data: {
+            result: finalResult,
+            usage: finalUsage,
+            cost: finalCost,
+          },
         },
-      });
+        eventContext
+      );
     } else {
       const interrupted = signal.aborted && outcome.status === "cancelled";
-      await this.appendEvent(sessionId, {
-        type: "turn.failed",
-        turnId,
-        data: {
-          message: interrupted
-            ? "turn interrupted"
-            : (outcome.errorMessage ??
-              (outcome.status === "cancelled"
-                ? "turn cancelled"
-                : "turn failed")),
+      await this.appendEvent(
+        sessionId,
+        {
+          type: "turn.failed",
+          turnId,
+          data: {
+            status: outcome.status,
+            message: interrupted
+              ? "turn interrupted"
+              : (outcome.errorMessage ??
+                (outcome.status === "cancelled"
+                  ? "turn cancelled"
+                  : "turn failed")),
+          },
         },
-      });
+        eventContext
+      );
     }
 
     const current = await this.sessions.get(sessionId);
@@ -2450,15 +2384,20 @@ export class SessionEngine {
               type: "session.failed",
               turnId,
               data: { message: outcome.errorMessage ?? "task failed" },
-            }
+            },
+        eventContext
       );
       await this.wipeCloudSessionWorkspace(sessionId);
     } else {
-      await this.appendEvent(sessionId, {
-        type: "session.waiting",
-        turnId,
-        data: {},
-      });
+      await this.appendEvent(
+        sessionId,
+        {
+          type: "session.waiting",
+          turnId,
+          data: {},
+        },
+        eventContext
+      );
     }
 
     return {
@@ -2658,16 +2597,17 @@ export class SessionEngine {
 
   private async buildTurnRequest(
     record: SessionRecord,
-    agent: ResolvedAgent,
     turnId: string,
     prompt: string,
     isFirstTurn: boolean,
     instructionsInvisibleToHarness: boolean,
     emit: (payload: SessionEventPayload) => void,
+    eventContext: EventDispatchContext,
     onUpdate: RunnerTurnRequest["onUpdate"],
     signal: AbortSignal,
     images?: Array<{ data: string; mimeType: string }>
   ): Promise<RunnerTurnRequest> {
+    const agent = this.project.agent;
     // Per-session cloud attach (channel/tool handoff) forces cloud runtime
     // even when the agent defaults to local for chat server tools.
     const runtime = resolveSessionRuntime({
@@ -2875,9 +2815,7 @@ export class SessionEngine {
         ? {}
         : { sdkAgentId: record.sdkAgentId }),
       workspaceDir: this.harnessCwd(record),
-      sandbox: authoredRoot
-        ? false
-        : this.project.agent.local?.sandbox === true,
+      sandbox: authoredRoot ? false : agent.local?.sandbox === true,
       ...(runtime === "local" && harnessTools !== undefined
         ? {
             ...(harnessTools.tools === undefined
@@ -2910,13 +2848,7 @@ export class SessionEngine {
         : {}),
       customTools:
         runtime === "local"
-          ? await this.buildCustomTools(
-              record,
-              agent,
-              turnId,
-              emit,
-              synthesized
-            )
+          ? await this.buildCustomTools(record, turnId, emit, synthesized)
           : {},
       mcpServers: this.buildMcpServers(
         runtime,
@@ -2944,16 +2876,21 @@ export class SessionEngine {
           sdkAgentId,
         }));
         record.sdkAgentId = sdkAgentId;
-        await this.appendEvent(record.sessionId, {
-          type: "agent.bound",
-          turnId,
-          data: {
-            sdkAgentId,
-            ...(sdkAgentId.startsWith("bc-")
-              ? { url: `https://cursor.com/agents/${sdkAgentId}` }
-              : {}),
+        eventContext.session = { ...eventContext.session, sdkAgentId };
+        await this.appendEvent(
+          record.sessionId,
+          {
+            type: "agent.bound",
+            turnId,
+            data: {
+              sdkAgentId,
+              ...(sdkAgentId.startsWith("bc-")
+                ? { url: `https://cursor.com/agents/${sdkAgentId}` }
+                : {}),
+            },
           },
-        });
+          eventContext
+        );
       },
     };
   }
@@ -3208,11 +3145,11 @@ export class SessionEngine {
 
   private async buildCustomTools(
     record: SessionRecord,
-    agent: ResolvedAgent,
     turnId: string,
     emit: (payload: SessionEventPayload) => void,
     extraTools: DiscoveredTool[] = []
   ): Promise<Record<string, SDKCustomTool>> {
+    const agent = this.project.agent;
     const tools: Record<string, SDKCustomTool> = {};
     const register = (tool: ResolvedAgent["tools"][number]): void => {
       tools[tool.name] = {
@@ -4606,21 +4543,26 @@ export class SessionEngine {
 
   private async appendEvent(
     sessionId: string,
-    payload: SessionEventPayload & { turnId?: string }
+    payload: SessionEventPayload & { turnId?: string },
+    context?: EventDispatchContext
   ): Promise<SessionEvent> {
     const log = await this.logs.get(sessionId);
     const event = log.append(payload);
-    this.queueDispatch(sessionId, event);
+    this.queueDispatch(sessionId, event, context);
     return event;
   }
 
-  private queueDispatch(sessionId: string, event: SessionEvent): void {
+  private queueDispatch(
+    sessionId: string,
+    event: SessionEvent,
+    context?: EventDispatchContext
+  ): void {
     // Single funnel for both append paths (appendEvent + the held-log emit),
     // so the storage sink sees every durable event exactly once.
     this.storage?.event(event);
     const chain = this.dispatchChains.get(sessionId) ?? Promise.resolve();
     const next = chain
-      .then(() => this.dispatchEvent(sessionId, event))
+      .then(() => this.dispatchEvent(sessionId, event, context))
       .catch((error) => {
         this.logger(
           `[agent-sdk] event dispatch failed for ${sessionId}: ${describeError(error)}`
@@ -4637,16 +4579,27 @@ export class SessionEngine {
 
   private async dispatchEvent(
     sessionId: string,
-    event: SessionEvent
+    event: SessionEvent,
+    context?: EventDispatchContext
   ): Promise<void> {
     const record = await this.sessions.get(sessionId);
     if (record === undefined) {
       return;
     }
+    const channelState =
+      context === undefined
+        ? (record.channelState ?? null)
+        : context.channelState;
+    const channelStateBefore =
+      context === undefined ? undefined : structuredClone(channelState);
 
     const sessionCtx: SessionContext = {
-      session: this.sessionInfo(record),
+      session: context?.session ?? this.sessionInfo(record),
       host: this.hostForSession(record.sessionId),
+      artifacts: this.artifactsApi({
+        sessionId: record.sessionId,
+        turnId: event.turnId,
+      }),
     };
     const channelEvents = this.channelEventHandlersFor(record.channelId);
     if (channelEvents !== undefined) {
@@ -4658,7 +4611,7 @@ export class SessionEngine {
       ];
       const channelCtx = {
         channelId: record.channelId,
-        state: (record.channelState ?? null) as JsonValue,
+        state: channelState,
         continuationToken: record.continuationKey,
         setContinuationToken: (token: string | null) =>
           this.setContinuationToken(sessionId, token),
@@ -4675,8 +4628,21 @@ export class SessionEngine {
           );
         }
       }
-      // Handlers mutate channel state in place; persist after each batch.
-      await this.updateRecord(sessionId, (current) => ({ ...current }));
+      if (context === undefined || channelStateBefore === undefined) {
+        // Handlers mutate live channel state in place; save the current record.
+        await this.updateRecord(sessionId, (current) => ({ ...current }));
+      } else {
+        const updatedState = channelCtx.state as JsonValue;
+        context.channelState = updatedState;
+        await this.updateRecord(sessionId, (current) => ({
+          ...current,
+          channelState: mergeChannelStateMutation({
+            current: current.channelState,
+            before: channelStateBefore,
+            after: updatedState,
+          }),
+        }));
+      }
     }
 
     for (const hook of this.project.hooks) {
@@ -4697,10 +4663,6 @@ export class SessionEngine {
               continuationToken: record.continuationKey,
             },
             stateRoot: this.stateRoot,
-            artifacts: this.artifactsApi({
-              sessionId: record.sessionId,
-              turnId: event.turnId,
-            }),
           });
         } catch (error) {
           this.logger(
@@ -4710,14 +4672,6 @@ export class SessionEngine {
       }
     }
 
-    if (this.abCollector.enabled) {
-      await this.abCollector.onEvent(
-        event,
-        sessionCtx.session,
-        this.project.name
-      );
-    }
-
     this.otel?.onEvent(event, sessionCtx.session);
   }
 
@@ -4776,6 +4730,10 @@ export class SessionEngine {
         await active;
         continue;
       }
+      const dispatch = this.dispatchChains.get(sessionId);
+      if (dispatch !== undefined) {
+        await dispatch.catch(() => {});
+      }
       return this.lastOutcomes.get(sessionId) ?? { status: "finished" };
     }
   }
@@ -5033,61 +4991,6 @@ export class SessionEngine {
       });
   }
 
-  /**
-   * Fold durable session streams into per-session A/B assignments and
-   * aggregate arm metrics (`GET /v1/abs`). Collector-independent: always
-   * reads `events.ndjson`.
-   */
-  async abSnapshot(
-    caller: AuthContext | null,
-    options?: { includeAll?: boolean }
-  ): Promise<ABSnapshot> {
-    const sessions = await this.listSessions(caller, options);
-    const abConfig = this.project.abConfig;
-    const maxPlaygroundSessions = resolveABMaxPlaygroundSessions(
-      abConfig?.maxPlaygroundSessions
-    );
-    const foldedSessions = sessions.slice(0, maxPlaygroundSessions);
-    // Backfill for a replacement host with nothing local to fold (e.g.
-    // lazy-only restore before any session resumed): serve the persisted
-    // aggregate instead of an empty surface. Gated on the host having no
-    // sessions AT ALL — the persisted snapshot spans every principal, so a
-    // caller who merely owns no sessions must not see it. Loaded once per
-    // process (playground polls this route ~every 4s); skip the persist
-    // side effect below — re-saving a restored snapshot would echo stale
-    // data back into the store.
-    if (
-      foldedSessions.length === 0 &&
-      this.storage !== undefined &&
-      (await this.sessions.list()).length === 0
-    ) {
-      this.restoredAbSnapshot ??= this.storage.getLatestAbSnapshot();
-      const restoredSnapshot = await this.restoredAbSnapshot;
-      if (restoredSnapshot !== undefined) {
-        return restoredSnapshot;
-      }
-    }
-    const abTable = this.project.storage?.abs;
-    const snapshot = await buildABSnapshot({
-      experiments: this.project.abs,
-      agentName: this.project.name,
-      sessions: foldedSessions,
-      loadRecord: (sessionId) => this.sessions.get(sessionId),
-      loadEvents: (sessionId) => this.listEvents(sessionId, 0),
-      sessionInfo: (record) => this.sessionInfo(record),
-      logger: this.logger,
-      config: {
-        maxPlaygroundSessions,
-        durableSamples: abTable !== undefined,
-        durableSnapshots: abTable?.putSnapshot !== undefined,
-      },
-    });
-    // Side effect on the read path: playground polls GET /v1/abs ~every 4s;
-    // the coordinator throttles the actual table write.
-    this.storage?.abSnapshot(snapshot);
-    return snapshot;
-  }
-
   async eventStream(
     sessionId: string,
     startIndex = 0
@@ -5347,7 +5250,6 @@ export class SessionEngine {
       asOf: record.asOf,
       auth: record.auth,
       continuationKey: record.continuationKey,
-      ...(record.abs === undefined ? {} : { abs: record.abs }),
       ...(record.title === undefined ? {} : { title: record.title }),
       ...(record.sdkAgentId === undefined
         ? {}
@@ -5449,9 +5351,9 @@ export class SessionEngine {
    * serve start, before channels accept traffic: any persisted session
    * missing from the local `--state-root` is materialized there — events
    * as `events.ndjson`, record as `session.json` — after which every
-   * existing read path (continuation lookup, event replay/streams, A/B
-   * fold hydration) works unchanged. Local state always wins over the
-   * sink, so restarts on the same host are no-ops.
+   * existing read path (continuation lookup, event replay/streams) works
+   * unchanged. Local state always wins over the sink, so restarts on the
+   * same host are no-ops.
    *
    * Failures are logged and skipped; a broken store (including rows that
    * violate the SessionRecord shape) never blocks serve start.
@@ -5770,38 +5672,6 @@ function mergePendingWorkspaceFiles(
   return { ...current, ...incoming };
 }
 
-/**
- * Shallow-merge a wake patch into durable channel state. Null / undefined
- * patch values leave the existing key alone so sticky fields survive.
- */
-export function mergeChannelStateSkipNull(
-  current: JsonValue | undefined,
-  patch: JsonValue | undefined
-): JsonValue | undefined {
-  if (patch === undefined) {
-    return current;
-  }
-  if (
-    typeof patch !== "object" ||
-    patch === null ||
-    Array.isArray(patch) ||
-    typeof current !== "object" ||
-    current === null ||
-    Array.isArray(current)
-  ) {
-    return structuredClone(patch);
-  }
-  const merged: Record<string, JsonValue> = {
-    ...(current as Record<string, JsonValue>),
-  };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value !== null && value !== undefined) {
-      merged[key] = value as JsonValue;
-    }
-  }
-  return merged;
-}
-
 function eventsNdjson(events: SessionEvent[]): string | undefined {
   if (events.length === 0) {
     return undefined;