@cursor/july 0.1.108 → 0.1.111

package/src/internal/session-engine.ts

@@ -8,16 +8,10 @@
  */
 
 import { AsyncLocalStorage } from "node:async_hooks";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { access, 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,
@@ -185,7 +176,12 @@ import {
   SCHEDULE_CHANNEL_PREFIX,
 } from "./prompt-context.js";
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
-import { applyAuthoredResult } from "./result-output.js";
+import {
+  addTurnUsage,
+  applyAuthoredResult,
+  RESULT_REPAIR_BUDGET,
+  resultRepairPrompt,
+} from "./result-output.js";
 import type { AgentRunner, SteerAckOutcome } from "./sdk-runner.js";
 import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
@@ -252,6 +248,21 @@ export class SessionBusyError extends Error {
   }
 }
 
+/**
+ * Hosted enqueue-only admission could not coalesce into an active turn.
+ * Distinct from {@link SessionBusyError}: the caller asked not to start work.
+ */
+export class HostedEnqueueNotActiveError extends Error {
+  constructor(sessionId?: string) {
+    super(
+      sessionId === undefined
+        ? "Hosted enqueue requires an active accepting session"
+        : `Hosted enqueue requires an active turn on session ${sessionId}`
+    );
+    this.name = "HostedEnqueueNotActiveError";
+  }
+}
+
 // Defined in auth.js (HTTP/session-store callers import it without this
 // module); re-exported here because this is its historical public home.
 export { SessionAuthError } from "./auth.js";
@@ -423,6 +434,12 @@ export interface EngineSendOptions extends SendMessageOptions {
    * authors cannot choose a session id through the public SendMessageOptions.
    */
   hostedSessionId?: string;
+  /**
+   * Hosted active-guest enqueue: admit only by coalescing into an already
+   * running turn. Never creates a session or starts a turn. Private host
+   * plumbing — not part of public SendMessageOptions.
+   */
+  hostedEnqueueOnly?: boolean;
 }
 
 interface CoalescedQueuedTurn {
@@ -438,6 +455,39 @@ interface AdmitTurnOptions {
    * coalesce drain so asks that arrived during drain are not wiped.
    */
   retainCoalesced?: boolean;
+  /** See {@link EngineSendOptions.hostedEnqueueOnly}. */
+  hostedEnqueueOnly?: boolean;
+}
+
+/** Marker that we `git init`'d this shared harness so scaffold is ours to write. */
+const OWNED_HARNESS = join(".agent-serve", "owned-harness");
+
+function pathExists(path: string): Promise<boolean> {
+  return access(path).then(
+    () => true,
+    () => false
+  );
+}
+
+/**
+ * Nested dirs get their own git root so the harness does not ripwalk the
+ * enclosing checkout. A real `workspaceDir` checkout (already a git root)
+ * is left alone.
+ */
+async function ownSharedHarness(dir: string): Promise<boolean> {
+  if (await pathExists(join(dir, OWNED_HARNESS))) {
+    return true;
+  }
+  if (!(await isNestedInGitRepo(dir))) {
+    return false;
+  }
+  await ensureOwnGitRoot(dir);
+  if (await isNestedInGitRepo(dir)) {
+    return false;
+  }
+  await mkdir(join(dir, ".agent-serve"), { recursive: true });
+  await writeFile(join(dir, OWNED_HARNESS), "");
+  return true;
 }
 
 export class SessionEngine {
@@ -455,8 +505,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. */
@@ -464,8 +514,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>>();
 
@@ -504,6 +552,8 @@ export class SessionEngine {
   private readonly turnAborts = new Map<string, AbortController>();
   /** Serializes turn admission per session (latest follow-up wins). */
   private readonly admissionChains = new Map<string, Promise<unknown>>();
+  /** Live turn snapshot so a coalesced Slack wake can repaint on this process. */
+  private readonly liveTurns = new Map<string, EventDispatchContext>();
   /** FIFO turn slots under `concurrency.maxRunningTurns` (unlimited when unset). */
   private readonly turnGovernor: TurnGovernor;
   /**
@@ -528,7 +578,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;
@@ -559,6 +608,8 @@ export class SessionEngine {
     string,
     { root: FileSystem; cwd: string }
   >();
+  /** In-flight `prewarmSharedWorkspace`; first turn waits so it lands hot. */
+  private sharedWarm: Promise<void> | undefined;
 
   constructor(options: SessionEngineOptions) {
     this.project = options.project;
@@ -587,7 +638,7 @@ export class SessionEngine {
     );
     this.outbox = new TurnOutbox(join(options.stateRoot, "outbox"));
     this.logs = new EventLogStore(
-      (sessionId) => this.sessions.eventFilePath(sessionId),
+      sessionId => this.sessions.eventFilePath(sessionId),
       (sessionId, error) =>
         this.logger(
           `[agent-sdk] failed to persist events for ${sessionId}: ${describeError(error)}`
@@ -639,13 +690,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.
@@ -654,7 +698,7 @@ export class SessionEngine {
         ...options.project.agent.connections,
         ...(options.project.agent.hostConnections ?? []),
       ].filter(
-        (connection) => !isSymbolicConnectionTransport(connection.transport)
+        connection => !isSymbolicConnectionTransport(connection.transport)
       )
     );
     const basePlatforms = options.platforms ?? createHostPlatforms();
@@ -707,8 +751,8 @@ export class SessionEngine {
 
   private authoredConnection(name: string): DiscoveredConnection | undefined {
     return (
-      this.project.agent.connections.find((item) => item.name === name) ??
-      this.project.agent.hostConnections?.find((item) => item.name === name)
+      this.project.agent.connections.find(item => item.name === name) ??
+      this.project.agent.hostConnections?.find(item => item.name === name)
     );
   }
 
@@ -777,7 +821,7 @@ export class SessionEngine {
    */
   artifactsApi(binding?: { sessionId: string; turnId?: string }): ArtifactsApi {
     return {
-      tag: async (input) => {
+      tag: async input => {
         if (binding === undefined) {
           return this.tagArtifact(input);
         }
@@ -795,7 +839,7 @@ export class SessionEngine {
           turnId: input.turnId ?? binding.turnId,
         });
       },
-      list: (filter) => this.artifactsStore.list(filter),
+      list: filter => this.artifactsStore.list(filter),
     };
   }
 
@@ -944,11 +988,11 @@ export class SessionEngine {
 
   private slackNudgeHostApi(): SlackNudgeHostApi {
     return {
-      append: (input) => this.nudgeStore.append(input),
-      drainFormatted: (continuationKey) =>
+      append: input => this.nudgeStore.append(input),
+      drainFormatted: continuationKey =>
         this.nudgeStore.drainFormatted(continuationKey),
-      clear: (continuationKey) => this.nudgeStore.clear(continuationKey),
-      hasUndelivered: (continuationKey) =>
+      clear: continuationKey => this.nudgeStore.clear(continuationKey),
+      hasUndelivered: continuationKey =>
         this.nudgeStore.hasUndelivered(continuationKey),
       isDelivered: (continuationKey, sourceTs) =>
         this.nudgeStore.isDelivered(continuationKey, sourceTs),
@@ -1058,61 +1102,76 @@ export class SessionEngine {
       // Refresh harness cwd when the caller supplies a newer worktree (e.g. PR
       // synchronize). Leave the durable continuation key unchanged.
       let record = existing;
-      const refreshWorkspace =
-        sendOptions.workspaceDir !== undefined &&
-        sendOptions.workspaceDir !== existing.workspaceOverride;
-      if (
-        refreshWorkspace ||
-        sendOptions.workspaceFiles !== undefined ||
-        sendOptions.images !== undefined
-      ) {
-        record = await this.updateRecord(existing.sessionId, (current) => ({
-          ...current,
-          workspaceOverride: refreshWorkspace
-            ? sendOptions.workspaceDir
-            : current.workspaceOverride,
-          pendingWorkspaceFiles: mergePendingWorkspaceFiles(
-            current.pendingWorkspaceFiles,
-            sendOptions.workspaceFiles
-          ),
-          pendingImages: mergePendingImages(
-            current.pendingImages,
-            sendOptions.images
-          ),
-        }));
-      }
-      // Refresh the cloud attach the same way: a follow-up send carries the
-      // caller's CURRENT cloud options (e.g. a PR attach re-derived per wake),
-      // and the first send's snapshot must not pin this session's turns to a
-      // stale repo/prUrl for the session's lifetime.
-      if (
-        sendOptions.cloud !== undefined &&
-        JSON.stringify(sendOptions.cloud) !==
-          JSON.stringify(record.cloudOverride)
-      ) {
-        record = await this.updateRecord(record.sessionId, (current) => ({
-          ...current,
-          cloudOverride: sendOptions.cloud,
-        }));
-      }
-      // Refresh wake-derived channel state (GitHub headSha / refs) without
-      // wiping sticky fields. Null patch values are skipped.
-      if (sendOptions.refreshState !== undefined) {
-        record = await this.updateRecord(record.sessionId, (current) => ({
-          ...current,
-          channelState: mergeChannelStateSkipNull(
-            current.channelState,
-            sendOptions.refreshState
-          ),
-        }));
+      const enqueueOnly = sendOptions.hostedEnqueueOnly === true;
+      if (!enqueueOnly) {
+        const refreshWorkspace =
+          sendOptions.workspaceDir !== undefined &&
+          sendOptions.workspaceDir !== existing.workspaceOverride;
+        if (
+          refreshWorkspace ||
+          sendOptions.workspaceFiles !== undefined ||
+          sendOptions.images !== undefined
+        ) {
+          record = await this.updateRecord(existing.sessionId, current => ({
+            ...current,
+            workspaceOverride: refreshWorkspace
+              ? sendOptions.workspaceDir
+              : current.workspaceOverride,
+            pendingWorkspaceFiles: mergePendingWorkspaceFiles(
+              current.pendingWorkspaceFiles,
+              sendOptions.workspaceFiles
+            ),
+            pendingImages: mergePendingImages(
+              current.pendingImages,
+              sendOptions.images
+            ),
+          }));
+        }
+        // Refresh the cloud attach the same way: a follow-up send carries the
+        // caller's CURRENT cloud options (e.g. a PR attach re-derived per wake),
+        // and the first send's snapshot must not pin this session's turns to a
+        // stale repo/prUrl for the session's lifetime.
+        if (
+          sendOptions.cloud !== undefined &&
+          JSON.stringify(sendOptions.cloud) !==
+            JSON.stringify(record.cloudOverride)
+        ) {
+          record = await this.updateRecord(record.sessionId, current => ({
+            ...current,
+            cloudOverride: sendOptions.cloud,
+          }));
+        }
+        // Refresh wake-derived channel state (GitHub headSha / refs) without
+        // wiping sticky fields. Null patch values are skipped.
+        if (sendOptions.refreshState !== undefined) {
+          record = await this.updateRecord(record.sessionId, current => ({
+            ...current,
+            channelState: mergeChannelStateSkipNull(
+              current.channelState,
+              sendOptions.refreshState
+            ),
+          }));
+        }
       }
       const since = (await this.logs.get(record.sessionId)).count;
       const coalesced = await this.startTurn(record.sessionId, message, {
-        admission: sendOptions.admission ?? "preempt",
+        admission: enqueueOnly
+          ? "coalesce"
+          : (sendOptions.admission ?? "preempt"),
         ...(sendOptions.coalesceSourceTs === undefined
           ? {}
           : { sourceTs: sendOptions.coalesceSourceTs }),
+        ...(enqueueOnly ? { hostedEnqueueOnly: true } : {}),
       });
+      if (enqueueOnly && !coalesced) {
+        throw new HostedEnqueueNotActiveError(record.sessionId);
+      }
+      if (!enqueueOnly && coalesced && sendOptions.refreshState !== undefined) {
+        await this.repaintOnCoalescedRefresh(
+          record.sessionId,
+          sendOptions.refreshState
+        );
+      }
       return this.channelSession(
         record.sessionId,
         record,
@@ -1122,6 +1181,10 @@ export class SessionEngine {
       );
     }
 
+    if (sendOptions.hostedEnqueueOnly === true) {
+      throw new HostedEnqueueNotActiveError(sendOptions.hostedSessionId);
+    }
+
     if (sendOptions.hostedSessionId !== undefined) {
       const collision = await this.getOrRestoreSession(
         sendOptions.hostedSessionId
@@ -1138,7 +1201,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",
@@ -1167,7 +1230,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",
@@ -1191,7 +1253,7 @@ export class SessionEngine {
     const stale = new Error("stale HTTP continuation");
     let previous: string | undefined;
     try {
-      await this.updateRecord(sessionId, (record) => {
+      await this.updateRecord(sessionId, record => {
         const expectedChannel =
           record.httpContinuationKey === undefined
             ? record.channelId
@@ -1214,7 +1276,7 @@ export class SessionEngine {
       await this.startTurn(sessionId, message);
       return next;
     } catch (error) {
-      await this.updateRecord(sessionId, (record) =>
+      await this.updateRecord(sessionId, record =>
         record.httpContinuationKey === next
           ? { ...record, httpContinuationKey: previous }
           : record
@@ -1241,97 +1303,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,
@@ -1396,6 +1367,53 @@ export class SessionEngine {
   // Turn execution
   // ==========================================================================
 
+  /**
+   * Repaint on the follow-up wake without retargeting the live turn.
+   * Persist already took the refresh; in-flight writes stay on the carrier ts.
+   */
+  private async repaintOnCoalescedRefresh(
+    sessionId: string,
+    patch: JsonValue | undefined
+  ): Promise<void> {
+    const live = this.liveTurns.get(sessionId);
+    if (live === undefined || patch === undefined) {
+      return;
+    }
+    const repaintState =
+      mergeChannelStateSkipNull(live.channelState, patch) ?? live.channelState;
+    const record = await this.sessions.get(sessionId);
+    if (record === undefined) {
+      return;
+    }
+    const handler = this.channelEventHandlersFor(record.channelId)?.[
+      "message.received"
+    ];
+    if (handler === undefined) {
+      return;
+    }
+    await handler(
+      {
+        type: "message.received",
+        data: { text: "" },
+        index: 0,
+        sessionId,
+        at: new Date().toISOString(),
+      },
+      {
+        channelId: record.channelId,
+        state: repaintState,
+        continuationToken: record.continuationKey,
+        setContinuationToken: (token: string | null) =>
+          this.setContinuationToken(sessionId, token),
+      },
+      {
+        session: live.session,
+        host: this.hostForSession(sessionId),
+        artifacts: this.artifactsApi({ sessionId }),
+      }
+    );
+  }
+
   /**
    * Admit a turn for `sessionId`.
    *
@@ -1417,7 +1435,12 @@ export class SessionEngine {
       .catch(() => {})
       .then(async () => {
         // Another server holds the turn: hand the message to it and coalesce.
+        // Enqueue-only must not report coalesced success without a local
+        // enqueue — the outbox drain may never run on this process.
         if (await this.turnLeases.runningElsewhere(sessionId)) {
+          if (options.hostedEnqueueOnly === true) {
+            throw new HostedEnqueueNotActiveError(sessionId);
+          }
           await this.outbox.post(sessionId, { message, options });
           return true;
         }
@@ -1434,7 +1457,7 @@ export class SessionEngine {
   private drainOutbox(sessionId: string): void {
     void this.outbox
       .takeAll(sessionId)
-      .then((items) => {
+      .then(items => {
         for (const item of items) {
           void this.startTurn(sessionId, item.message, item.options).catch(
             () => {}
@@ -1448,7 +1471,7 @@ export class SessionEngine {
     const queue = this.coalesceQueues.get(sessionId) ?? [];
     if (
       item.sourceTs !== undefined &&
-      queue.some((entry) => entry.sourceTs === item.sourceTs)
+      queue.some(entry => entry.sourceTs === item.sourceTs)
     ) {
       return;
     }
@@ -1529,7 +1552,7 @@ export class SessionEngine {
     }
     const parts = [
       "<slack_followups>",
-      `ANSWER-EACH: ${items.length} asks arrived while you were busy. Address each in order; keep replies compact.`,
+      `${items.length} asks arrived while you were busy.`,
       "",
     ];
     for (let i = 0; i < items.length; i++) {
@@ -1623,11 +1646,21 @@ export class SessionEngine {
     // enqueue: `drainCoalescedFollowups` reads only this process's queue, so
     // the shared nudge store is the carrier. Not redundant with `acquire`
     // below — this returns before preempt's `clearCoalesced` drops the queue.
+    // Enqueue-only cannot claim coalesced here: nothing joined a local turn.
     if (await this.turnLeases.runningElsewhere(sessionId)) {
+      if (options.hostedEnqueueOnly === true) {
+        throw new HostedEnqueueNotActiveError(sessionId);
+      }
       this.logger(`[session] coalesce; another server owns ${sessionId}`);
       return true;
     }
 
+    // Enqueue-only must never start a turn (or preempt/interrupt). Steer and
+    // coalesce above already returned true when they absorbed the message.
+    if (options.hostedEnqueueOnly === true) {
+      throw new HostedEnqueueNotActiveError(sessionId);
+    }
+
     // Interrupt any turn in flight and wait for it to settle so the SDK run is
     // terminal before this turn's send (the follow-up also force-expires as a
     // belt-and-suspenders — see buildTurnRequest). Drain-resume skips interrupt:
@@ -1656,12 +1689,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;
 
@@ -1704,6 +1735,7 @@ export class SessionEngine {
           };
         } finally {
           clearInterval(poll);
+          this.liveTurns.delete(sessionId);
         }
         this.lastOutcomes.set(sessionId, outcome);
         const wasCurrent = this.activeTurns.get(sessionId) === lifecycle;
@@ -1713,14 +1745,19 @@ export class SessionEngine {
         if (this.turnAborts.get(sessionId) === abort) {
           this.turnAborts.delete(sessionId);
         }
-        if (wasCurrent && !abort.signal.aborted) {
-          const drain = this.drainCoalescedFollowups(sessionId).catch(
-            (error) => {
-              this.logger(
-                `[session] coalesce drain failed for ${sessionId}: ${describeError(error)}`
-              );
-            }
-          );
+        // Failed/cancelled owners must not start a coalesced successor.
+        // Hosted execute would then 503 and Temporal/FIFO would re-run the
+        // same follow-ups as full deliveries.
+        if (
+          wasCurrent &&
+          !abort.signal.aborted &&
+          outcome.status === "finished"
+        ) {
+          const drain = this.drainCoalescedFollowups(sessionId).catch(error => {
+            this.logger(
+              `[session] coalesce drain failed for ${sessionId}: ${describeError(error)}`
+            );
+          });
           this.coalesceDrains.set(sessionId, drain);
           try {
             await drain;
@@ -1980,7 +2017,7 @@ export class SessionEngine {
     if (turn === undefined) {
       return tools;
     }
-    return tools.map((tool) => {
+    return tools.map(tool => {
       const execute = tool.definition.execute;
       if (typeof execute !== "function") {
         return tool;
@@ -2157,6 +2194,13 @@ export class SessionEngine {
    * Best effort — warming is an optimization, and a turn rebuilds on its own.
    */
   async prewarmSharedWorkspace(): Promise<void> {
+    if (this.sharedWarm === undefined) {
+      this.sharedWarm = this.warmSharedWorkspace();
+    }
+    await this.sharedWarm;
+  }
+
+  private async warmSharedWorkspace(): Promise<void> {
     const agent = this.project.agent;
     const workspaceDir = agent.local?.workspaceDir;
     if (
@@ -2169,6 +2213,15 @@ export class SessionEngine {
     }
     const startedAt = Date.now();
     try {
+      await mkdir(workspaceDir, { recursive: true });
+      if (await ownSharedHarness(workspaceDir)) {
+        await materializeWorkspace({
+          agent,
+          workspaceDir,
+          seed: true,
+          stateRoot: this.stateRoot,
+        });
+      }
       const harness = resolveHostHarnessToolOptions(agent.allowedTools);
       const outcome = await this.runner.prewarm({
         workspaceDir,
@@ -2182,7 +2235,10 @@ export class SessionEngine {
         // warmed without an identity; the per-send flag still has to match
         // the turns' requests or the warmed executor is one no turn asks for.
         mcpServers: this.buildMcpServers("local"),
-        ...(this.hasAttachedAuthedConnections()
+        ...(this.hasAttachedAuthedConnections() ||
+        this.project.agent.connections.some(connection =>
+          isCursorAccountTransport(connection.transport)
+        )
           ? { perSendMcpServers: true }
           : {}),
         subagents: buildRunnerSubagents(agent),
@@ -2226,6 +2282,7 @@ export class SessionEngine {
       channelState: structuredClone(turnChannelState),
       session: this.sessionInfo(record),
     };
+    this.liveTurns.set(sessionId, eventContext);
     // 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.
@@ -2243,7 +2300,7 @@ export class SessionEngine {
     // Read by closure, so the mapper still sees it while draining after the
     // registry entry below is gone.
     const stubbed = new Set<string>();
-    const mapper = new TurnEventMapper(emit, (callId) => stubbed.has(callId));
+    const mapper = new TurnEventMapper(emit, callId => stubbed.has(callId));
 
     // Take a turn slot before any work happens. When every slot is busy the
     // turn waits FIFO — durable `turn.queued` marks the wait — and a
@@ -2252,7 +2309,7 @@ export class SessionEngine {
     const permit = await this.turnGovernor.acquire({
       sessionId,
       signal,
-      onQueued: (position) => {
+      onQueued: position => {
         const maxRunningTurns = this.turnGovernor.maxRunningTurns ?? 0;
         emit({ type: "turn.queued", data: { position, maxRunningTurns } });
         this.logger(
@@ -2268,13 +2325,17 @@ export class SessionEngine {
     } else {
       emit({ type: "turn.started", data: {} });
       try {
+        if (
+          record.workspaceOverride === undefined &&
+          this.project.agent.local?.workspaceDir !== undefined
+        ) {
+          await this.prewarmSharedWorkspace();
+        }
         // 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,
@@ -2296,7 +2357,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 =
@@ -2314,7 +2375,7 @@ export class SessionEngine {
           (hasPendingFiles && runtime !== "cloud") ||
           (pendingImages !== undefined && pendingImages.length > 0)
         ) {
-          await this.updateRecord(sessionId, (current) => ({
+          await this.updateRecord(sessionId, current => ({
             ...current,
             pendingWorkspaceFiles:
               hasPendingFiles &&
@@ -2328,49 +2389,39 @@ export class SessionEngine {
                 : current.pendingImages,
           }));
         }
-        // The harness only loads the scaffolded AGENTS.md when the session
-        // workspace is its own project root. When the harness cwd is borrowed
-        // (PR worktree, shared checkout) the scaffold lands elsewhere, and a
-        // workspace nested inside a git repo re-roots harness rules at that
-        // repo — in both cases deliver instructions inline on the first turn.
-        const instructionsInvisibleToHarness =
-          isFirstTurn &&
-          (this.hasBorrowedWorkspace(record) ||
-            (await isNestedInGitRepo(harnessCwd)));
+        const onUpdate: RunnerTurnRequest["onUpdate"] = async update => {
+          const turn = this.turnRoots.get(sessionId);
+          if (turn !== undefined) {
+            update = await applyWebScratchUpdate({
+              cwd: turn.cwd,
+              root: turn.root,
+              update,
+            });
+          }
+          mapper.handleUpdate(update);
+          // Yield so the HTTP NDJSON writer can flush tool start/result
+          // events while sibling parallel tools are still executing.
+          if (
+            update.type === "tool-call-started" ||
+            update.type === "tool-call-completed" ||
+            // Nested subagent progress (newer SDKs); string check keeps
+            // typecheck green against older published `@cursor/sdk` pins.
+            (update as { type: string }).type === "tool-call-delta"
+          ) {
+            // Same boundary the carrier hook runs on, so a drain is visible
+            // by the time this fires.
+            await this.emitDeliveredNudges(record, emit);
+            await yieldEventLoop();
+          }
+        };
         const request = await this.buildTurnRequest(
           record,
-          agent,
           turnId,
           message,
           isFirstTurn,
-          instructionsInvisibleToHarness,
           emit,
           eventContext,
-          async (update) => {
-            const turn = this.turnRoots.get(sessionId);
-            if (turn !== undefined) {
-              update = await applyWebScratchUpdate({
-                cwd: turn.cwd,
-                root: turn.root,
-                update,
-              });
-            }
-            mapper.handleUpdate(update);
-            // Yield so the HTTP NDJSON writer can flush tool start/result
-            // events while sibling parallel tools are still executing.
-            if (
-              update.type === "tool-call-started" ||
-              update.type === "tool-call-completed" ||
-              // Nested subagent progress (newer SDKs); string check keeps
-              // typecheck green against older published `@cursor/sdk` pins.
-              (update as { type: string }).type === "tool-call-delta"
-            ) {
-              // Same boundary the carrier hook runs on, so a drain is visible
-              // by the time this fires.
-              await this.emitDeliveredNudges(record, emit);
-              await yieldEventLoop();
-            }
-          },
+          onUpdate,
           signal,
           pendingImages
         );
@@ -2380,6 +2431,20 @@ export class SessionEngine {
           outcome = await this.runTurnExecute(record, turnId, () =>
             this.runner.runTurn(request)
           );
+          // Commit before dropping the turn FS so `ctx.reject` can
+          // re-run the model with tools still mounted.
+          outcome = await this.settleAuthoredResult({
+            record,
+            turnId,
+            emit,
+            eventContext,
+            turnChannelState,
+            harnessCwd,
+            signal,
+            onUpdate,
+            mapper,
+            outcome,
+          });
         } finally {
           this.activeToolContexts.delete(sessionId);
           this.stubbedCallIds.delete(sessionId);
@@ -2409,7 +2474,7 @@ export class SessionEngine {
 
     if (mapper.title !== undefined) {
       const title = mapper.title;
-      await this.updateRecord(sessionId, (current) => ({ ...current, title }));
+      await this.updateRecord(sessionId, current => ({ ...current, title }));
       eventContext.session = { ...eventContext.session, title };
     }
 
@@ -2428,32 +2493,6 @@ export class SessionEngine {
       outcome = { ...outcome, cost: finalCost };
     }
 
-    const authored = this.project.result;
-    if (outcome.status === "finished" && authored !== undefined) {
-      const settled = await applyAuthoredResult({
-        definition: authored,
-        text: finalResult,
-        dryRun: record.dryRun === true,
-        ctx: {
-          session: eventContext.session,
-          channelState: turnChannelState,
-          host: this.hostForSession(sessionId),
-          artifacts: this.artifactsApi({ sessionId, turnId }),
-          stateRoot: this.stateRoot,
-          workspaceDir: harnessCwd,
-        },
-      });
-      if (!settled.ok) {
-        outcome = {
-          status: "error",
-          result: finalResult,
-          errorMessage: `turn output failed: ${settled.message}`,
-          usage: finalUsage,
-          cost: finalCost,
-        };
-      }
-    }
-
     if (outcome.status === "finished") {
       await this.appendEvent(
         sessionId,
@@ -2523,6 +2562,89 @@ export class SessionEngine {
     };
   }
 
+  /**
+   * Run `defineResult` while the turn FS and tools are still up.
+   * `ctx.reject` re-invokes `runTurn` on this turnId until commit
+   * succeeds, throws, or the repair budget is gone.
+   */
+  private async settleAuthoredResult(args: {
+    record: SessionRecord;
+    turnId: string;
+    emit: (payload: SessionEventPayload) => void;
+    eventContext: EventDispatchContext;
+    turnChannelState: JsonValue;
+    harnessCwd: string;
+    signal: AbortSignal;
+    onUpdate: RunnerTurnRequest["onUpdate"];
+    mapper: TurnEventMapper;
+    outcome: TurnOutcome;
+  }): Promise<TurnOutcome> {
+    const authored = this.project.result;
+    if (args.outcome.status !== "finished" || authored === undefined) {
+      return args.outcome;
+    }
+
+    let outcome = args.outcome;
+    let usage = outcome.usage;
+    let repairs = 0;
+
+    while (true) {
+      const settled = await applyAuthoredResult({
+        definition: authored,
+        text: outcome.result ?? args.mapper.pendingText,
+        dryRun: args.record.dryRun === true,
+        ctx: {
+          session: args.eventContext.session,
+          channelState: args.turnChannelState,
+          host: this.hostForSession(args.record.sessionId),
+          artifacts: this.artifactsApi({
+            sessionId: args.record.sessionId,
+            turnId: args.turnId,
+          }),
+          stateRoot: this.stateRoot,
+          workspaceDir: args.harnessCwd,
+        },
+      });
+      if (settled.ok) {
+        return { ...outcome, result: settled.text, usage };
+      }
+      if (settled.kind === "error" || repairs >= RESULT_REPAIR_BUDGET) {
+        return {
+          status: "error",
+          result: outcome.result,
+          errorMessage: `turn output failed: ${settled.message}`,
+          usage,
+        };
+      }
+      repairs += 1;
+      // Close the rejected stream without posting it (empty `stop`)
+      // so Slack does not append a repair onto that block, and so an
+      // empty repair cannot recommit `lastAssistantText`.
+      args.mapper.abandonPendingText();
+      this.logger(
+        `[session] ${args.record.sessionId} ${args.turnId} result rejected; repairing (${repairs}/${RESULT_REPAIR_BUDGET})`
+      );
+      const repairRequest = await this.buildTurnRequest(
+        args.record,
+        args.turnId,
+        resultRepairPrompt(settled.message),
+        false,
+        args.emit,
+        args.eventContext,
+        args.onUpdate,
+        args.signal
+      );
+      const repaired = await this.runTurnExecute(args.record, args.turnId, () =>
+        this.runner.runTurn(repairRequest)
+      );
+      usage = addTurnUsage(usage, repaired.usage);
+      if (repaired.status !== "finished") {
+        return { ...repaired, usage };
+      }
+      outcome = { ...repaired, usage };
+    }
+  }
+
   /**
    * Sync authored skills onto the Agent Store at `skills/<name>/…` (hosted)
    * or `agent-serve/<agent>/skills/<name>/…` (personal-key local+cloud)
@@ -2615,7 +2737,7 @@ export class SessionEngine {
     sessionId: string,
     pending: NonNullable<SessionRecord["pendingWorkspaceFiles"]>
   ): Promise<void> {
-    await this.updateRecord(sessionId, (current) => ({
+    await this.updateRecord(sessionId, current => ({
       ...current,
       pendingWorkspaceFiles:
         current.pendingWorkspaceFiles === pending
@@ -2648,7 +2770,7 @@ export class SessionEngine {
     }
     let sync = run().then(
       () => true,
-      (error) => {
+      error => {
         this.logger(
           `[${surface}] ${store.label} sync failed: ${error instanceof Error ? error.message : String(error)}`
         );
@@ -2667,11 +2789,17 @@ export class SessionEngine {
   /**
    * Hosted deployments own the deployment store. Local `serve`/`run` with
    * a personal API key writes into the USER store under `agent-serve/`.
+   * A persistent deployment's version container has no cloud store at all:
+   * its state directory is the durable copy, and its service-account key
+   * must not be mistaken for a personal one.
    */
   private cloudStore(): CloudStoreTarget | undefined {
     const v2Hosting = resolveAgentV2Hosting({
       architecture: this.project.agent.architecture,
     });
+    if (v2Hosting.kind === "cursor-managed-persistent") {
+      return undefined;
+    }
     const deployment = {
       mountPath: DEPLOYMENT_STORE_MOUNT_PATH,
       skillsPrefix: agentStoreKeys.skillsPrefix(),
@@ -2713,17 +2841,16 @@ 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({
@@ -2758,7 +2885,7 @@ export class SessionEngine {
     // agents already fail discovery; this guards hybrid agents' per-send
     // cloud sessions.
     const perSessionConnection = agent.connections.find(
-      (connection) =>
+      connection =>
         connection.advertiseTools === true || connection.auth !== undefined
     );
     if (runtime !== "local" && perSessionConnection !== undefined) {
@@ -2812,7 +2939,7 @@ export class SessionEngine {
         : this.withTurnScratchTools(
             authoredRoot
               ? fileTools
-              : fileTools.filter((tool) => tool.name !== "SemanticSearch"),
+              : fileTools.filter(tool => tool.name !== "SemanticSearch"),
             record.sessionId
           );
     let turnPrompt = prompt;
@@ -2888,6 +3015,9 @@ export class SessionEngine {
           }
         }
       } else if (pending !== undefined && Object.keys(pending).length > 0) {
+        this.logger(
+          `[workspace] no cloud store on this hosting; dropping workspaceFiles for session ${record.sessionId}: ${Object.keys(pending).join(", ")}`
+        );
         await this.clearPendingWorkspaceFiles(record.sessionId, pending);
       }
       if (isFirstTurn && hosted) {
@@ -2895,45 +3025,33 @@ export class SessionEngine {
       }
       if (preamble !== "" || sections.length > 0) {
         turnPrompt = [preamble, ...sections, turnPrompt]
-          .filter((part) => part !== "")
+          .filter(part => part !== "")
           .join("\n\n");
       }
     } else if (isFirstTurn && runtime === "local" && authoredRoot) {
-      // Virtual roots skip materialize, so AGENTS.md never lands on disk.
-      // Ship the same preamble the borrowed-cwd local path uses.
-      const preamble = buildAgentsMdContent(
-        { ...agent, tools: [...agent.tools, ...synthesized] },
-        { includeScripts: true }
-      );
-      const workspaceInfo = `<user_info>\nWorkspace Path: /\n</user_info>`;
-      turnPrompt =
-        preamble === ""
-          ? `${workspaceInfo}\n\n${turnPrompt}`
-          : `${workspaceInfo}\n\n${preamble}\n\n${turnPrompt}`;
-    } else if (
-      isFirstTurn &&
-      runtime === "local" &&
-      instructionsInvisibleToHarness
-    ) {
-      // Local workspace whose AGENTS.md the harness will not load. With a
-      // borrowed harness cwd, agent tool scripts live only in the durable
-      // scaffold dir — embed bodies like cloud. Otherwise the catalog can
-      // reference on-disk paths under the harness cwd. Grokbot turns are
-      // excluded: their instructions ride the request's `instructions`
-      // field into the Sand system prompt instead.
-      const includeScripts = this.hasBorrowedWorkspace(record);
-      const preamble = buildAgentsMdContent(agent, { includeScripts });
-      turnPrompt = `${preamble}\n\n${turnPrompt}`;
+      // The harness reports no path for a root it never mounted.
+      turnPrompt = `<user_info>\nWorkspace Path: /\n</user_info>\n\n${turnPrompt}`;
     }
+    // A virtual root has no scaffold dir either, so its catalog carries the
+    // synthesized file tools and embedded script bodies.
+    const localInstructions =
+      runtime === "local"
+        ? authoredRoot
+          ? buildAgentsMdContent(
+              { ...agent, tools: [...agent.tools, ...synthesized] },
+              { includeScripts: true }
+            )
+          : buildAgentsMdContent(agent, {
+              includeScripts: this.hasBorrowedWorkspace(record),
+            })
+        : undefined;
     return {
       sessionId: record.sessionId,
       ...(record.sdkAgentId === undefined
         ? {}
         : { 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
@@ -2952,34 +3070,35 @@ export class SessionEngine {
       runtime,
       agentName: agent.name,
       ...(mergedCloud === undefined ? {} : { cloud: mergedCloud }),
-      // The hosted Grok Bot harness reads no workspace AGENTS.md: grokbot
-      // turns carry the composed instructions into the hosted session,
-      // which surfaces them in the Sand system prompt. The box never sees
-      // the local session workspace, so agent-tool script bodies are
-      // always embedded — same rule as the cloud first-prompt preamble.
+      // Local turns send the composed instructions as the harness system
+      // prompt; grokbot turns carry them into the hosted session, which
+      // surfaces them in the Sand system prompt. Cloud turns inline them into
+      // the first prompt above instead. Script bodies are embedded whenever
+      // the harness cannot reach the scaffold dir: always for grokbot (the
+      // box never sees the session workspace) and for a borrowed local cwd
+      // (PR worktree, shared checkout); otherwise the catalog references the
+      // on-disk paths under the harness cwd.
       instructions:
         runtime === "grokbot"
           ? buildAgentsMdContent(agent, { includeScripts: true })
-          : undefined,
+          : localInstructions,
       ...(runtime === "cloud" && !isCursorHostedFilesAvailable()
         ? { agentServeAgent: this.project.name }
         : {}),
       customTools:
         runtime === "local"
-          ? await this.buildCustomTools(
-              record,
-              agent,
-              turnId,
-              emit,
-              synthesized
-            )
+          ? await this.buildCustomTools(record, turnId, emit, synthesized)
           : {},
       mcpServers: this.buildMcpServers(
         runtime,
         record.sessionId,
         await this.evaluateConnectionAuth(record)
       ),
-      ...(runtime === "local" && this.hasAttachedAuthedConnections()
+      ...(runtime === "local" &&
+      (this.hasAttachedAuthedConnections() ||
+        this.project.agent.connections.some(connection =>
+          isCursorAccountTransport(connection.transport)
+        ))
         ? { perSendMcpServers: true }
         : {}),
       subagents: buildRunnerSubagents(agent),
@@ -2988,14 +3107,14 @@ export class SessionEngine {
       // Local follow-ups expire any lingering active run so a preempted turn
       // (or one orphaned by a crashed process) never blocks this send.
       forceExpireActiveRun: runtime === "local" && !isFirstTurn,
-      onRequestId: (requestId) => {
+      onRequestId: requestId => {
         emit({ type: "turn.bound", data: { requestId } });
       },
-      onSdkAgentId: async (sdkAgentId) => {
+      onSdkAgentId: async sdkAgentId => {
         if (record.sdkAgentId === sdkAgentId) {
           return;
         }
-        await this.updateRecord(record.sessionId, (current) => ({
+        await this.updateRecord(record.sessionId, current => ({
           ...current,
           sdkAgentId,
         }));
@@ -3097,12 +3216,12 @@ export class SessionEngine {
     // attached MCP server (each tool appears exactly once).
     const advertisedNames = new Set(
       this.project.agent.connections
-        .filter((connection) => connection.advertiseTools === true)
-        .map((connection) => connection.name)
+        .filter(connection => connection.advertiseTools === true)
+        .map(connection => connection.name)
     );
     const hostConnectionNames = new Set(
       (this.project.agent.hostConnections ?? []).map(
-        (connection) => connection.name
+        connection => connection.name
       )
     );
     const bridgedNames = new Set(
@@ -3116,7 +3235,7 @@ export class SessionEngine {
     assertCloudCanHonorAccountServersFilters({
       runtime,
       resolvedConnections: this.resolvedConnections.filter(
-        (resolved) =>
+        resolved =>
           !advertisedNames.has(resolved.name) &&
           !hostConnectionNames.has(resolved.name)
       ),
@@ -3189,6 +3308,20 @@ export class SessionEngine {
         }
         continue;
       }
+      const authored = this.authoredConnection(resolved.name);
+      if (
+        sessionId !== undefined &&
+        authored !== undefined &&
+        isCursorAccountTransport(authored.transport)
+      ) {
+        const bound = new URL(url);
+        bound.searchParams.set("agentkitSessionId", sessionId);
+        servers[resolved.name] = {
+          url: bound.toString(),
+          headers: resolved.headers,
+        };
+        continue;
+      }
       servers[resolved.name] = {
         url,
         headers: resolved.headers,
@@ -3198,7 +3331,7 @@ export class SessionEngine {
       runtime === "cloud" &&
       sessionId !== undefined &&
       this.cloudServerToolsConnection !== undefined &&
-      this.project.agent.tools.some((tool) => tool.execution === "server")
+      this.project.agent.tools.some(tool => tool.execution === "server")
     ) {
       if (servers[SERVER_TOOLS_MCP_SERVER_NAME] !== undefined) {
         throw new Error(
@@ -3226,7 +3359,7 @@ export class SessionEngine {
    */
   private hasAttachedAuthedConnections(): boolean {
     return this.project.agent.connections.some(
-      (connection) =>
+      connection =>
         connection.auth !== undefined && connection.advertiseTools !== true
     );
   }
@@ -3242,7 +3375,7 @@ export class SessionEngine {
     record: SessionRecord
   ): Promise<ReadonlyMap<string, Record<string, string>> | undefined> {
     const authed = this.project.agent.connections.filter(
-      (connection) =>
+      connection =>
         connection.auth !== undefined && connection.advertiseTools !== true
     );
     if (authed.length === 0) {
@@ -3269,11 +3402,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] = {
@@ -3358,7 +3491,7 @@ export class SessionEngine {
       );
     }
     const tool = this.project.agent.tools.find(
-      (candidate) =>
+      candidate =>
         candidate.name === toolName && candidate.execution === "server"
     );
     if (tool === undefined) {
@@ -3605,11 +3738,11 @@ export class SessionEngine {
       args.sessionId,
       pendingRecord
     );
-    await this.updateRecord(args.sessionId, (current) => ({
+    await this.updateRecord(args.sessionId, current => ({
       ...current,
       pendingApprovals: [
         ...(current.pendingApprovals ?? []).filter(
-          (item) => item.callId !== args.callId
+          item => item.callId !== args.callId
         ),
         pendingRecord,
       ],
@@ -3626,10 +3759,10 @@ export class SessionEngine {
       `[session] tool ${args.toolName} awaiting approval (${args.callId})`
     );
     const { decision, by } = await resolutionPromise;
-    await this.updateRecord(args.sessionId, (current) => ({
+    await this.updateRecord(args.sessionId, current => ({
       ...current,
       pendingApprovals: (current.pendingApprovals ?? []).filter(
-        (item) => item.callId !== args.callId
+        item => item.callId !== args.callId
       ),
     }));
     args.emit({
@@ -3656,7 +3789,7 @@ export class SessionEngine {
     ) {
       return;
     }
-    await this.updateRecord(sessionId, (record) => ({
+    await this.updateRecord(sessionId, record => ({
       ...record,
       pendingApprovals: [],
     }));
@@ -3699,8 +3832,8 @@ export class SessionEngine {
       throw new SessionAuthError(sessionId);
     }
     const pending =
-      (record.pendingApprovals ?? []).find((item) => item.callId === callId) ??
-      this.approvals.list(sessionId).find((item) => item.callId === callId);
+      (record.pendingApprovals ?? []).find(item => item.callId === callId) ??
+      this.approvals.list(sessionId).find(item => item.callId === callId);
     if (pending === undefined) {
       throw new ApprovalNotFoundError(sessionId, callId);
     }
@@ -3716,10 +3849,10 @@ export class SessionEngine {
     sessionId: string,
     callId: string
   ): Promise<void> {
-    await this.updateRecord(sessionId, (current) => ({
+    await this.updateRecord(sessionId, current => ({
       ...current,
       pendingApprovals: (current.pendingApprovals ?? []).filter(
-        (item) => item.callId !== callId
+        item => item.callId !== callId
       ),
     }));
   }
@@ -3727,7 +3860,7 @@ export class SessionEngine {
   private wrapMcp(inner: McpHost): HostMcpRegistry {
     return {
       names: () => inner.names(),
-      listTools: (name) => this.withMcpAuth(name, () => inner.listTools(name)),
+      listTools: name => this.withMcpAuth(name, () => inner.listTools(name)),
       callTool: (name, tool, args) =>
         this.withMcpAuth(name, () => inner.callTool(name, tool, args)),
     };
@@ -3735,11 +3868,11 @@ export class SessionEngine {
 
   private advertiseMcp(): AdvertiseHostMcp {
     return {
-      listTools: (name) =>
+      listTools: name =>
         this.withMcpListAuth(name, () => this.mcpHost.listTools(name)),
       callTool: (name, tool, args) =>
         this.withMcpAuth(name, () => this.mcpHost.callTool(name, tool, args)),
-      oneOff: (connection) => {
+      oneOff: connection => {
         const inner = this.mcpHost.oneOff(connection);
         return {
           listTools: () =>
@@ -3892,11 +4025,11 @@ export class SessionEngine {
       requestedAt,
     };
     const resolutionPromise = this.auths.wait(args.sessionId, pendingRecord);
-    await this.updateRecord(args.sessionId, (current) => ({
+    await this.updateRecord(args.sessionId, current => ({
       ...current,
       pendingAuths: [
         ...(current.pendingAuths ?? []).filter(
-          (item) => item.callId !== args.callId
+          item => item.callId !== args.callId
         ),
         pendingRecord,
       ],
@@ -3914,10 +4047,10 @@ export class SessionEngine {
       `[session] tool ${args.toolName} awaiting MCP auth ${args.connection} (${args.callId})`
     );
     const { decision, by } = await resolutionPromise;
-    await this.updateRecord(args.sessionId, (current) => ({
+    await this.updateRecord(args.sessionId, current => ({
       ...current,
       pendingAuths: (current.pendingAuths ?? []).filter(
-        (item) => item.callId !== args.callId
+        item => item.callId !== args.callId
       ),
     }));
     args.emit({
@@ -3946,7 +4079,7 @@ export class SessionEngine {
     ) {
       return;
     }
-    await this.updateRecord(sessionId, (record) => ({
+    await this.updateRecord(sessionId, record => ({
       ...record,
       pendingAuths: [],
     }));
@@ -3980,8 +4113,8 @@ export class SessionEngine {
       throw new SessionAuthError(sessionId);
     }
     const pending =
-      (record.pendingAuths ?? []).find((item) => item.callId === callId) ??
-      this.auths.list(sessionId).find((item) => item.callId === callId);
+      (record.pendingAuths ?? []).find(item => item.callId === callId) ??
+      this.auths.list(sessionId).find(item => item.callId === callId);
     if (pending === undefined) {
       throw new AuthNotFoundError(sessionId, callId);
     }
@@ -4000,10 +4133,10 @@ export class SessionEngine {
     sessionId: string,
     callId: string
   ): Promise<void> {
-    await this.updateRecord(sessionId, (current) => ({
+    await this.updateRecord(sessionId, current => ({
       ...current,
       pendingAuths: (current.pendingAuths ?? []).filter(
-        (item) => item.callId !== callId
+        item => item.callId !== callId
       ),
     }));
   }
@@ -4211,17 +4344,17 @@ export class SessionEngine {
       }
   > {
     const authored = this.project.agent.tools.find(
-      (tool) => tool.name === toolName
+      tool => tool.name === toolName
     );
     if (authored !== undefined) {
       return { tool: authored };
     }
     const catalog = await this.listCatalogTools(options);
-    const tool = catalog.tools.find((entry) => entry.name === toolName);
+    const tool = catalog.tools.find(entry => entry.name === toolName);
     if (tool === undefined) {
       return {
         tool: undefined,
-        availableTools: catalog.tools.map((entry) => entry.name),
+        availableTools: catalog.tools.map(entry => entry.name),
         connectionErrors: catalog.connectionErrors,
       };
     }
@@ -4263,10 +4396,10 @@ export class SessionEngine {
     if (native !== undefined) {
       return native;
     }
-    let tool = this.project.agent.tools.find((t) => t.name === toolName);
+    let tool = this.project.agent.tools.find(t => t.name === toolName);
     if (
       tool === undefined &&
-      this.project.agent.connections.some((c) => c.advertiseTools === true)
+      this.project.agent.connections.some(c => c.advertiseTools === true)
     ) {
       // Advertised passthroughs are ordinary server tools in the session's
       // namespace; resolve the live listing so direct calls address them by
@@ -4277,14 +4410,14 @@ export class SessionEngine {
         session,
         hostMcp: this.advertiseMcp(),
       });
-      tool = advertised.find((t) => t.name === toolName);
+      tool = advertised.find(t => t.name === toolName);
     }
     if (tool === undefined) {
       throw new UnknownToolError(
         toolName,
         this.project.agent.tools
-          .filter((t) => t.execution === "server")
-          .map((t) => t.name)
+          .filter(t => t.execution === "server")
+          .map(t => t.name)
       );
     }
     const execute = tool.definition.execute;
@@ -4655,7 +4788,7 @@ export class SessionEngine {
   ): Promise<HostMcpToolInfo | undefined> {
     try {
       const listed = await this.host.mcp.listTools(connectionName);
-      return listed.find((tool) => tool.name === toolName);
+      return listed.find(tool => tool.name === toolName);
     } catch {
       return undefined;
     }
@@ -4687,7 +4820,7 @@ export class SessionEngine {
     const chain = this.dispatchChains.get(sessionId) ?? Promise.resolve();
     const next = chain
       .then(() => this.dispatchEvent(sessionId, event, context))
-      .catch((error) => {
+      .catch(error => {
         this.logger(
           `[agent-sdk] event dispatch failed for ${sessionId}: ${describeError(error)}`
         );
@@ -4754,11 +4887,11 @@ export class SessionEngine {
       }
       if (context === undefined || channelStateBefore === undefined) {
         // Handlers mutate live channel state in place; save the current record.
-        await this.updateRecord(sessionId, (current) => ({ ...current }));
+        await this.updateRecord(sessionId, current => ({ ...current }));
       } else {
         const updatedState = channelCtx.state as JsonValue;
         context.channelState = updatedState;
-        await this.updateRecord(sessionId, (current) => ({
+        await this.updateRecord(sessionId, current => ({
           ...current,
           channelState: mergeChannelStateMutation({
             current: current.channelState,
@@ -4796,14 +4929,6 @@ export class SessionEngine {
       }
     }
 
-    if (this.abCollector.enabled) {
-      await this.abCollector.onEvent(
-        event,
-        sessionCtx.session,
-        this.project.name
-      );
-    }
-
     this.otel?.onEvent(event, sessionCtx.session);
   }
 
@@ -4850,8 +4975,10 @@ export class SessionEngine {
   async waitForCompletion(sessionId: string): Promise<TurnOutcome> {
     // Drain admission first so pendingTurns → activeTurns is visible before we
     // decide the session is idle (reminders use this for queueBehindTurn).
-    // The active lifecycle promise also awaits coalesce drain + the drained
-    // follow-up's admission, so Slack coalesced waiters see the resume turn.
+    // Wait for coalesce drain and any successor turn so hosted execute does
+    // not park mid-follow-up, but report the root turn's outcome: a drained
+    // successor failure must not un-ACK an already-finished owner.
+    let root: TurnOutcome | undefined;
     for (;;) {
       const chain = this.admissionChains.get(sessionId);
       if (chain !== undefined) {
@@ -4859,14 +4986,15 @@ export class SessionEngine {
       }
       const active = this.activeTurns.get(sessionId);
       if (active !== undefined) {
-        await active;
+        const outcome = await active;
+        root ??= outcome;
         continue;
       }
       const dispatch = this.dispatchChains.get(sessionId);
       if (dispatch !== undefined) {
         await dispatch.catch(() => {});
       }
-      return this.lastOutcomes.get(sessionId) ?? { status: "finished" };
+      return root ?? this.lastOutcomes.get(sessionId) ?? { status: "finished" };
     }
   }
 
@@ -4905,7 +5033,7 @@ export class SessionEngine {
     }
     const owned = await this.ownedSessionIds(caller);
     return records.filter(
-      (record) => record.sessionId !== undefined && owned.has(record.sessionId)
+      record => record.sessionId !== undefined && owned.has(record.sessionId)
     );
   }
 
@@ -4942,8 +5070,8 @@ export class SessionEngine {
     const sessions = await this.sessions.list();
     return new Set(
       sessions
-        .filter((record) => samePrincipal(record.auth, caller))
-        .map((record) => record.sessionId)
+        .filter(record => samePrincipal(record.auth, caller))
+        .map(record => record.sessionId)
     );
   }
 
@@ -5087,8 +5215,8 @@ export class SessionEngine {
     includeAll: boolean
   ): SessionSummary[] {
     return records
-      .filter((record) => includeAll || samePrincipal(record.auth, caller))
-      .map((record) => {
+      .filter(record => includeAll || samePrincipal(record.auth, caller))
+      .map(record => {
         const links = sessionExternalLinks(record);
         return {
           sessionId: record.sessionId,
@@ -5123,61 +5251,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
@@ -5202,7 +5275,7 @@ export class SessionEngine {
     if (existing === undefined) {
       throw new Error(`Unknown session: ${sessionId}`);
     }
-    const record = await this.updateRecord(sessionId, (current) => ({
+    const record = await this.updateRecord(sessionId, current => ({
       ...current,
       turnCount: current.turnCount + 1,
     }));
@@ -5337,7 +5410,7 @@ export class SessionEngine {
       return pending;
     }
     const work = this.runCloudTurnCostBackfill(sessionId)
-      .catch((error) => {
+      .catch(error => {
         this.logger(
           `[agent-sdk] cloud cost backfill failed for ${sessionId}: ${describeError(error)}`
         );
@@ -5352,10 +5425,10 @@ export class SessionEngine {
   private async runCloudTurnCostBackfill(sessionId: string): Promise<void> {
     const log = await this.logs.get(sessionId);
     const events = await log.snapshot(0);
-    if (!events.some((event) => isUnpricedCompletedTurn(event))) {
+    if (!events.some(event => isUnpricedCompletedTurn(event))) {
       if (
         !this.isTurnRunning(sessionId) &&
-        events.some((event) => event.type === "turn.completed")
+        events.some(event => event.type === "turn.completed")
       ) {
         this.cloudCostBackfillDone.add(sessionId);
       }
@@ -5386,7 +5459,7 @@ export class SessionEngine {
       log.replace(i, next);
     }
     if (
-      !(await log.snapshot(0)).some((event) => isUnpricedCompletedTurn(event))
+      !(await log.snapshot(0)).some(event => isUnpricedCompletedTurn(event))
     ) {
       this.cloudCostBackfillDone.add(sessionId);
     }
@@ -5397,7 +5470,7 @@ export class SessionEngine {
     token: string | null
   ): Promise<void> {
     const previous = await this.sessions.get(sessionId);
-    await this.updateRecord(sessionId, (current) => ({
+    await this.updateRecord(sessionId, current => ({
       ...current,
       continuationKey: token,
     }));
@@ -5437,7 +5510,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
         ? {}
@@ -5539,9 +5611,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.
@@ -5575,7 +5647,7 @@ export class SessionEngine {
     // the lazy continuation-lookup path.
     const cutoff = Date.now() - policy.maxAgeMs;
     const candidates = loaded
-      .map((record) => ({
+      .map(record => ({
         record,
         // Numeric timestamp for both the age filter and the sort; a
         // non-string updatedAt (e.g. a raw DB Date from an untyped sink)
@@ -5607,7 +5679,7 @@ export class SessionEngine {
     ) {
       const chunk = candidates.slice(i, i + RESTORE_FETCH_CONCURRENCY);
       const fetched = await Promise.all(
-        chunk.map(async (record) => {
+        chunk.map(async record => {
           try {
             // Local state always wins over the sink.
             if ((await this.sessions.get(record.sessionId)) !== undefined) {
@@ -5864,7 +5936,7 @@ function eventsNdjson(events: SessionEvent[]): string | undefined {
   if (events.length === 0) {
     return undefined;
   }
-  return `${events.map((event) => JSON.stringify(event)).join("\n")}\n`;
+  return `${events.map(event => JSON.stringify(event)).join("\n")}\n`;
 }
 
 function subagentPrompt(subagent: ResolvedAgent): string {
@@ -5880,7 +5952,7 @@ function subagentPrompt(subagent: ResolvedAgent): string {
  * executor that turn will run on.
  */
 function buildRunnerSubagents(agent: ResolvedAgent): RunnerSubagent[] {
-  return agent.subagents.map((subagent) => ({
+  return agent.subagents.map(subagent => ({
     name: subagent.name,
     description: subagent.description ?? subagent.name,
     prompt: subagentPrompt(subagent),
@@ -5904,7 +5976,7 @@ async function defaultGetCloudUsage(
     return {
       usage: mapSdkTokenUsage(billed.usage),
       cost: billed.cost,
-      runs: billed.runs.map((run) => ({
+      runs: billed.runs.map(run => ({
         runId: run.runId,
         usage: mapSdkTokenUsage(run.usage),
         cost: run.cost,
@@ -5956,7 +6028,7 @@ function approvalResolverLabel(auth: AuthContext | null): string | undefined {
 
 /** Let the HTTP NDJSON writer flush before the next SDK update. */
 function yieldEventLoop(): Promise<void> {
-  return new Promise((resolve) => {
+  return new Promise(resolve => {
     setImmediate(resolve);
   });
 }