@cursor/july 0.1.109 → 0.1.112

package/src/internal/session-engine.ts

@@ -8,7 +8,7 @@
  */
 
 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";
@@ -176,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";
@@ -243,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";
@@ -414,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 {
@@ -429,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 {
@@ -493,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;
   /**
@@ -547,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;
@@ -575,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)}`
@@ -635,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();
@@ -688,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)
     );
   }
 
@@ -758,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);
         }
@@ -776,7 +839,7 @@ export class SessionEngine {
           turnId: input.turnId ?? binding.turnId,
         });
       },
-      list: (filter) => this.artifactsStore.list(filter),
+      list: filter => this.artifactsStore.list(filter),
     };
   }
 
@@ -925,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),
@@ -974,6 +1037,11 @@ export class SessionEngine {
       // on a sessionless pod.
       throw new HostedAdmissionLocalSendError();
     }
+    if (options.clearCloudOverride === true && options.cloud !== undefined) {
+      throw new Error(
+        "send options cloud and clearCloudOverride cannot be combined"
+      );
+    }
     const identity =
       channelId === HTTP_CHANNEL_ID
         ? httpContinuationIdentity(this.project.httpChannel)
@@ -1039,61 +1107,83 @@ 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
+            ),
+          }));
+        }
+        // A caller can explicitly return a continuation to the agent's
+        // configured runtime. Omission remains sticky for compatibility:
+        // follow-ups that do not know the original attach keep it.
+        if (
+          sendOptions.clearCloudOverride === true &&
+          record.cloudOverride !== undefined
+        ) {
+          record = await this.updateRecord(record.sessionId, current => ({
+            ...current,
+            cloudOverride: undefined,
+          }));
+        } else 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,
@@ -1103,6 +1193,10 @@ export class SessionEngine {
       );
     }
 
+    if (sendOptions.hostedEnqueueOnly === true) {
+      throw new HostedEnqueueNotActiveError(sendOptions.hostedSessionId);
+    }
+
     if (sendOptions.hostedSessionId !== undefined) {
       const collision = await this.getOrRestoreSession(
         sendOptions.hostedSessionId
@@ -1171,7 +1265,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
@@ -1194,7 +1288,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
@@ -1285,6 +1379,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`.
    *
@@ -1306,7 +1447,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;
         }
@@ -1323,7 +1469,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(
             () => {}
@@ -1337,7 +1483,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;
     }
@@ -1418,7 +1564,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++) {
@@ -1512,11 +1658,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:
@@ -1545,7 +1701,7 @@ export class SessionEngine {
 
     let lifecycleInstalled = false;
     try {
-      const record = await this.updateRecord(sessionId, (current) => ({
+      const record = await this.updateRecord(sessionId, current => ({
         ...current,
         turnCount: current.turnCount + 1,
       }));
@@ -1591,6 +1747,7 @@ export class SessionEngine {
           };
         } finally {
           clearInterval(poll);
+          this.liveTurns.delete(sessionId);
         }
         this.lastOutcomes.set(sessionId, outcome);
         const wasCurrent = this.activeTurns.get(sessionId) === lifecycle;
@@ -1600,14 +1757,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;
@@ -1867,7 +2029,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;
@@ -2044,6 +2206,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 (
@@ -2056,6 +2225,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,
@@ -2069,7 +2247,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),
@@ -2113,6 +2294,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.
@@ -2130,7 +2312,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
@@ -2139,7 +2321,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(
@@ -2155,6 +2337,12 @@ 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).
         if (!this.hasRootOverride()) {
@@ -2199,7 +2387,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 &&
@@ -2213,48 +2401,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,
           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
         );
@@ -2264,6 +2443,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);
@@ -2293,7 +2486,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 };
     }
 
@@ -2312,32 +2505,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,
@@ -2407,6 +2574,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)
@@ -2499,7 +2749,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
@@ -2532,7 +2782,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)}`
         );
@@ -2551,11 +2801,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(),
@@ -2600,7 +2856,6 @@ export class SessionEngine {
     turnId: string,
     prompt: string,
     isFirstTurn: boolean,
-    instructionsInvisibleToHarness: boolean,
     emit: (payload: SessionEventPayload) => void,
     eventContext: EventDispatchContext,
     onUpdate: RunnerTurnRequest["onUpdate"],
@@ -2642,7 +2897,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) {
@@ -2696,7 +2951,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;
@@ -2772,6 +3027,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) {
@@ -2779,36 +3037,26 @@ 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
@@ -2834,15 +3082,18 @@ 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 }
         : {}),
@@ -2855,7 +3106,11 @@ export class SessionEngine {
         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),
@@ -2864,14 +3119,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,
         }));
@@ -2973,12 +3228,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(
@@ -2992,7 +3247,7 @@ export class SessionEngine {
     assertCloudCanHonorAccountServersFilters({
       runtime,
       resolvedConnections: this.resolvedConnections.filter(
-        (resolved) =>
+        resolved =>
           !advertisedNames.has(resolved.name) &&
           !hostConnectionNames.has(resolved.name)
       ),
@@ -3065,6 +3320,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,
@@ -3074,7 +3343,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(
@@ -3102,7 +3371,7 @@ export class SessionEngine {
    */
   private hasAttachedAuthedConnections(): boolean {
     return this.project.agent.connections.some(
-      (connection) =>
+      connection =>
         connection.auth !== undefined && connection.advertiseTools !== true
     );
   }
@@ -3118,7 +3387,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) {
@@ -3234,7 +3503,7 @@ export class SessionEngine {
       );
     }
     const tool = this.project.agent.tools.find(
-      (candidate) =>
+      candidate =>
         candidate.name === toolName && candidate.execution === "server"
     );
     if (tool === undefined) {
@@ -3481,11 +3750,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,
       ],
@@ -3502,10 +3771,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({
@@ -3532,7 +3801,7 @@ export class SessionEngine {
     ) {
       return;
     }
-    await this.updateRecord(sessionId, (record) => ({
+    await this.updateRecord(sessionId, record => ({
       ...record,
       pendingApprovals: [],
     }));
@@ -3575,8 +3844,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);
     }
@@ -3592,10 +3861,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
       ),
     }));
   }
@@ -3603,7 +3872,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)),
     };
@@ -3611,11 +3880,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: () =>
@@ -3768,11 +4037,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,
       ],
@@ -3790,10 +4059,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({
@@ -3822,7 +4091,7 @@ export class SessionEngine {
     ) {
       return;
     }
-    await this.updateRecord(sessionId, (record) => ({
+    await this.updateRecord(sessionId, record => ({
       ...record,
       pendingAuths: [],
     }));
@@ -3856,8 +4125,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);
     }
@@ -3876,10 +4145,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
       ),
     }));
   }
@@ -4087,17 +4356,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,
       };
     }
@@ -4139,10 +4408,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
@@ -4153,14 +4422,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;
@@ -4531,7 +4800,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;
     }
@@ -4563,7 +4832,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)}`
         );
@@ -4630,11 +4899,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,
@@ -4718,8 +4987,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) {
@@ -4727,14 +4998,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" };
     }
   }
 
@@ -4773,7 +5045,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)
     );
   }
 
@@ -4810,8 +5082,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)
     );
   }
 
@@ -4955,8 +5227,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,
@@ -5015,7 +5287,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,
     }));
@@ -5150,7 +5422,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)}`
         );
@@ -5165,10 +5437,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);
       }
@@ -5199,7 +5471,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);
     }
@@ -5210,7 +5482,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,
     }));
@@ -5387,7 +5659,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)
@@ -5419,7 +5691,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) {
@@ -5676,7 +5948,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 {
@@ -5692,7 +5964,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),
@@ -5716,7 +5988,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,
@@ -5768,7 +6040,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);
   });
 }