@cursor/july 0.1.109 → 0.1.111

package/dist/internal/session-engine.js

@@ -16,7 +16,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 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 { SLACK_CHANNEL_ID } from "../channels/slack/constants.js";
 import { materializeSlackNudgeCarrier } from "../channels/slack/nudge-carrier.js";
@@ -57,7 +57,7 @@ import { McpOauthOnDemandHub } from "./mcp-oauth-on-demand.js";
 import { shouldStartProcessMemoryTelemetry, startProcessMemoryTelemetry, } from "./process-memory-telemetry.js";
 import { buildSessionContextBlock, 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 { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
 import { syncSkillsToStore } from "./skills-sync.js";
@@ -81,6 +81,18 @@ export class SessionBusyError extends Error {
         this.name = "SessionBusyError";
     }
 }
+/**
+ * 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) {
+        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";
@@ -158,6 +170,33 @@ export class AuthInterruptedError extends Error {
     }
 }
 const mcpAuthAls = new AsyncLocalStorage();
+/** 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) {
+    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.
+ */
+function ownSharedHarness(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yield pathExists(join(dir, OWNED_HARNESS))) {
+            return true;
+        }
+        if (!(yield isNestedInGitRepo(dir))) {
+            return false;
+        }
+        yield ensureOwnGitRoot(dir);
+        if (yield isNestedInGitRepo(dir)) {
+            return false;
+        }
+        yield mkdir(join(dir, ".agent-serve"), { recursive: true });
+        yield writeFile(join(dir, OWNED_HARNESS), "");
+        return true;
+    });
+}
 export class SessionEngine {
     constructor(options) {
         var _a, _b, _c, _d, _e;
@@ -197,6 +236,8 @@ export class SessionEngine {
         this.turnAborts = new Map();
         /** Serializes turn admission per session (latest follow-up wins). */
         this.admissionChains = new Map();
+        /** Live turn snapshot so a coalesced Slack wake can repaint on this process. */
+        this.liveTurns = new Map();
         /**
          * Per-session coalesce queue for `admission: "coalesce"` (Slack). Drained
          * into one follow-up turn when the active turn finishes without interrupt.
@@ -245,7 +286,7 @@ export class SessionEngine {
         this.askDedupe = new SlackAskDedupeStore(join(options.stateRoot, "slack-asks"));
         this.turnLeases = new TurnLeaseStore(join(options.stateRoot, "turn-leases"));
         this.outbox = new TurnOutbox(join(options.stateRoot, "outbox"));
-        this.logs = new EventLogStore((sessionId) => this.sessions.eventFilePath(sessionId), (sessionId, error) => this.logger(`[agent-sdk] failed to persist events for ${sessionId}: ${describeError(error)}`));
+        this.logs = new EventLogStore(sessionId => this.sessions.eventFilePath(sessionId), (sessionId, error) => this.logger(`[agent-sdk] failed to persist events for ${sessionId}: ${describeError(error)}`));
         // Framework session state (records, event chunks, continuations) is
         // mirrored to whatever this selects; see framework-storage-selection.ts
         // for why the choice does not belong to the agent author.
@@ -289,7 +330,7 @@ export class SessionEngine {
         this.mcpHost = new McpHost([
             ...options.project.agent.connections,
             ...((_d = options.project.agent.hostConnections) !== null && _d !== void 0 ? _d : []),
-        ].filter((connection) => !isSymbolicConnectionTransport(connection.transport)));
+        ].filter(connection => !isSymbolicConnectionTransport(connection.transport)));
         const basePlatforms = (_e = options.platforms) !== null && _e !== void 0 ? _e : createHostPlatforms();
         const slackBinding = resolveDedicatedSlackHostBinding(options.project.channels);
         this.platforms =
@@ -333,7 +374,7 @@ export class SessionEngine {
     authoredConnection(name) {
         var _a;
         var _b;
-        return ((_b = this.project.agent.connections.find((item) => item.name === name)) !== null && _b !== void 0 ? _b : (_a = this.project.agent.hostConnections) === null || _a === void 0 ? void 0 : _a.find((item) => item.name === name));
+        return ((_b = this.project.agent.connections.find(item => item.name === name)) !== null && _b !== void 0 ? _b : (_a = this.project.agent.hostConnections) === null || _a === void 0 ? void 0 : _a.find(item => item.name === name));
     }
     setCloudServerToolsConnection(connection) {
         this.cloudServerToolsConnection = connection;
@@ -398,7 +439,7 @@ export class SessionEngine {
                 }
                 return this.tagArtifact(Object.assign(Object.assign({}, input), { sessionId: binding.sessionId, turnId: (_a = input.turnId) !== null && _a !== void 0 ? _a : binding.turnId }));
             }),
-            list: (filter) => this.artifactsStore.list(filter),
+            list: filter => this.artifactsStore.list(filter),
         };
     }
     /**
@@ -536,10 +577,10 @@ export class SessionEngine {
     }
     slackNudgeHostApi() {
         return {
-            append: (input) => this.nudgeStore.append(input),
-            drainFormatted: (continuationKey) => this.nudgeStore.drainFormatted(continuationKey),
-            clear: (continuationKey) => this.nudgeStore.clear(continuationKey),
-            hasUndelivered: (continuationKey) => this.nudgeStore.hasUndelivered(continuationKey),
+            append: input => this.nudgeStore.append(input),
+            drainFormatted: continuationKey => this.nudgeStore.drainFormatted(continuationKey),
+            clear: continuationKey => this.nudgeStore.clear(continuationKey),
+            hasUndelivered: continuationKey => this.nudgeStore.hasUndelivered(continuationKey),
             isDelivered: (continuationKey, sourceTs) => this.nudgeStore.isDelivered(continuationKey, sourceTs),
             tryClaimAsk: (channelId, messageTs) => this.askDedupe.tryClaim(channelId, messageTs),
             releaseAsk: (channelId, messageTs) => this.askDedupe.release(channelId, messageTs),
@@ -620,35 +661,49 @@ 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 = yield this.updateRecord(existing.sessionId, (current) => (Object.assign(Object.assign({}, 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 = yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, 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 = yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, 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 = yield this.updateRecord(existing.sessionId, current => (Object.assign(Object.assign({}, 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 = yield this.updateRecord(record.sessionId, current => (Object.assign(Object.assign({}, 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 = yield this.updateRecord(record.sessionId, current => (Object.assign(Object.assign({}, current), { channelState: mergeChannelStateSkipNull(current.channelState, sendOptions.refreshState) })));
+                    }
                 }
                 const since = (yield this.logs.get(record.sessionId)).count;
-                const coalesced = yield this.startTurn(record.sessionId, message, Object.assign({ admission: (_d = sendOptions.admission) !== null && _d !== void 0 ? _d : "preempt" }, (sendOptions.coalesceSourceTs === undefined
+                const coalesced = yield this.startTurn(record.sessionId, message, Object.assign(Object.assign({ admission: enqueueOnly
+                        ? "coalesce"
+                        : ((_d = sendOptions.admission) !== null && _d !== void 0 ? _d : "preempt") }, (sendOptions.coalesceSourceTs === undefined
                     ? {}
-                    : { sourceTs: sendOptions.coalesceSourceTs })));
+                    : { sourceTs: sendOptions.coalesceSourceTs })), (enqueueOnly ? { hostedEnqueueOnly: true } : {})));
+                if (enqueueOnly && !coalesced) {
+                    throw new HostedEnqueueNotActiveError(record.sessionId);
+                }
+                if (!enqueueOnly && coalesced && sendOptions.refreshState !== undefined) {
+                    yield this.repaintOnCoalescedRefresh(record.sessionId, sendOptions.refreshState);
+                }
                 return this.channelSession(record.sessionId, record, false, coalesced, since);
             }
+            if (sendOptions.hostedEnqueueOnly === true) {
+                throw new HostedEnqueueNotActiveError(sendOptions.hostedSessionId);
+            }
             if (sendOptions.hostedSessionId !== undefined) {
                 const collision = yield this.getOrRestoreSession(sendOptions.hostedSessionId);
                 if (collision !== undefined) {
@@ -706,7 +761,7 @@ export class SessionEngine {
             const stale = new Error("stale HTTP continuation");
             let previous;
             try {
-                yield this.updateRecord(sessionId, (record) => {
+                yield this.updateRecord(sessionId, record => {
                     var _a;
                     const expectedChannel = record.httpContinuationKey === undefined
                         ? record.channelId
@@ -730,7 +785,7 @@ export class SessionEngine {
                 return next;
             }
             catch (error) {
-                yield this.updateRecord(sessionId, (record) => record.httpContinuationKey === next
+                yield this.updateRecord(sessionId, record => record.httpContinuationKey === next
                     ? Object.assign(Object.assign({}, record), { httpContinuationKey: previous }) : record);
                 throw error;
             }
@@ -793,6 +848,45 @@ 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.
+     */
+    repaintOnCoalescedRefresh(sessionId, patch) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            var _b;
+            const live = this.liveTurns.get(sessionId);
+            if (live === undefined || patch === undefined) {
+                return;
+            }
+            const repaintState = (_b = mergeChannelStateSkipNull(live.channelState, patch)) !== null && _b !== void 0 ? _b : live.channelState;
+            const record = yield this.sessions.get(sessionId);
+            if (record === undefined) {
+                return;
+            }
+            const handler = (_a = this.channelEventHandlersFor(record.channelId)) === null || _a === void 0 ? void 0 : _a["message.received"];
+            if (handler === undefined) {
+                return;
+            }
+            yield handler({
+                type: "message.received",
+                data: { text: "" },
+                index: 0,
+                sessionId,
+                at: new Date().toISOString(),
+            }, {
+                channelId: record.channelId,
+                state: repaintState,
+                continuationToken: record.continuationKey,
+                setContinuationToken: (token) => this.setContinuationToken(sessionId, token),
+            }, {
+                session: live.session,
+                host: this.hostForSession(sessionId),
+                artifacts: this.artifactsApi({ sessionId }),
+            });
+        });
+    }
     /**
      * Admit a turn for `sessionId`.
      *
@@ -811,7 +905,12 @@ export class SessionEngine {
             .catch(() => { })
             .then(() => __awaiter(this, void 0, void 0, function* () {
             // 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 (yield this.turnLeases.runningElsewhere(sessionId)) {
+                if (options.hostedEnqueueOnly === true) {
+                    throw new HostedEnqueueNotActiveError(sessionId);
+                }
                 yield this.outbox.post(sessionId, { message, options });
                 return true;
             }
@@ -824,7 +923,7 @@ export class SessionEngine {
     drainOutbox(sessionId) {
         void this.outbox
             .takeAll(sessionId)
-            .then((items) => {
+            .then(items => {
             for (const item of items) {
                 void this.startTurn(sessionId, item.message, item.options).catch(() => { });
             }
@@ -835,7 +934,7 @@ export class SessionEngine {
         var _a;
         const queue = (_a = this.coalesceQueues.get(sessionId)) !== null && _a !== void 0 ? _a : [];
         if (item.sourceTs !== undefined &&
-            queue.some((entry) => entry.sourceTs === item.sourceTs)) {
+            queue.some(entry => entry.sourceTs === item.sourceTs)) {
             return;
         }
         queue.push(item);
@@ -905,7 +1004,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++) {
@@ -988,10 +1087,19 @@ 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 (yield 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:
@@ -1020,7 +1128,7 @@ export class SessionEngine {
             this.pendingTurns.add(sessionId);
             let lifecycleInstalled = false;
             try {
-                const record = yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { turnCount: current.turnCount + 1 })));
+                const record = yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { turnCount: current.turnCount + 1 })));
                 const turnId = `turn_${record.turnCount}`;
                 const isFirstTurn = record.turnCount === 1;
                 yield this.appendEvent(sessionId, {
@@ -1057,6 +1165,7 @@ export class SessionEngine {
                     }
                     finally {
                         clearInterval(poll);
+                        this.liveTurns.delete(sessionId);
                     }
                     this.lastOutcomes.set(sessionId, outcome);
                     const wasCurrent = this.activeTurns.get(sessionId) === lifecycle;
@@ -1066,8 +1175,13 @@ 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) => {
+                    // 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);
@@ -1291,7 +1405,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;
@@ -1449,6 +1563,14 @@ export class SessionEngine {
      * Best effort — warming is an optimization, and a turn rebuilds on its own.
      */
     prewarmSharedWorkspace() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.sharedWarm === undefined) {
+                this.sharedWarm = this.warmSharedWorkspace();
+            }
+            yield this.sharedWarm;
+        });
+    }
+    warmSharedWorkspace() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const agent = this.project.agent;
@@ -1461,6 +1583,15 @@ export class SessionEngine {
             }
             const startedAt = Date.now();
             try {
+                yield mkdir(workspaceDir, { recursive: true });
+                if (yield ownSharedHarness(workspaceDir)) {
+                    yield materializeWorkspace({
+                        agent,
+                        workspaceDir,
+                        seed: true,
+                        stateRoot: this.stateRoot,
+                    });
+                }
                 const harness = resolveHostHarnessToolOptions(agent.allowedTools);
                 const outcome = yield this.runner.prewarm(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ workspaceDir, runnerStateDir: join(this.stateRoot, "runner"), sandbox: ((_b = agent.local) === null || _b === void 0 ? void 0 : _b.sandbox) === true }, (harness.tools === undefined ? {} : { tools: harness.tools })), (harness.disallowedTools === undefined
                     ? {}
@@ -1468,7 +1599,8 @@ export class SessionEngine {
                     // No session yet, so auth'd connections are omitted rather than
                     // 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()
+                    mcpServers: this.buildMcpServers("local") }), (this.hasAttachedAuthedConnections() ||
+                    this.project.agent.connections.some(connection => isCursorAccountTransport(connection.transport))
                     ? { perSendMcpServers: true }
                     : {})), { subagents: buildRunnerSubagents(agent) }), (agent.model === undefined ? {} : { model: agent.model })));
                 // Report what happened rather than that the call returned: a runner
@@ -1492,15 +1624,17 @@ export class SessionEngine {
     }
     executeTurn(record, turnId, message, isFirstTurn, signal) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a;
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k;
             const sessionId = record.sessionId;
             const workspaceDir = this.scaffoldDir(record);
             const harnessCwd = this.harnessCwd(record);
-            const turnChannelState = structuredClone((_a = record.channelState) !== null && _a !== void 0 ? _a : null);
+            const turnChannelState = structuredClone((_b = record.channelState) !== null && _b !== void 0 ? _b : null);
             const eventContext = {
                 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.
@@ -1517,7 +1651,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();
-            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
             // preempting follow-up (or interrupt) resolves the wait as cancelled
@@ -1525,7 +1659,7 @@ export class SessionEngine {
             const permit = yield this.turnGovernor.acquire({
                 sessionId,
                 signal,
-                onQueued: (position) => {
+                onQueued: position => {
                     var _a;
                     const maxRunningTurns = (_a = this.turnGovernor.maxRunningTurns) !== null && _a !== void 0 ? _a : 0;
                     emit({ type: "turn.queued", data: { position, maxRunningTurns } });
@@ -1540,6 +1674,10 @@ export class SessionEngine {
             else {
                 emit({ type: "turn.started", data: {} });
                 try {
+                    if (record.workspaceOverride === undefined &&
+                        ((_a = this.project.agent.local) === null || _a === void 0 ? void 0 : _a.workspaceDir) !== undefined) {
+                        yield this.prewarmSharedWorkspace();
+                    }
                     // Scaffold agent files into the session workspace even when the harness
                     // cwd is overridden (e.g. a PR worktree).
                     if (!this.hasRootOverride()) {
@@ -1573,7 +1711,7 @@ export class SessionEngine {
                     if (hasPendingFiles && runtime !== "cloud") {
                         const root = yield this.resolveFileSystem({
                             sessionId,
-                            continuationKey: (_b = record.continuationKey) !== null && _b !== void 0 ? _b : undefined,
+                            continuationKey: (_c = record.continuationKey) !== null && _c !== void 0 ? _c : undefined,
                             cache: true,
                             cwd: harnessCwd,
                         });
@@ -1581,7 +1719,7 @@ export class SessionEngine {
                     }
                     if ((hasPendingFiles && runtime !== "cloud") ||
                         (pendingImages !== undefined && pendingImages.length > 0)) {
-                        yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { pendingWorkspaceFiles: hasPendingFiles &&
+                        yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { pendingWorkspaceFiles: hasPendingFiles &&
                                 runtime !== "cloud" &&
                                 current.pendingWorkspaceFiles === pendingFiles
                                 ? undefined
@@ -1589,15 +1727,7 @@ export class SessionEngine {
                                 ? undefined
                                 : 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) ||
-                            (yield isNestedInGitRepo(harnessCwd)));
-                    const request = yield this.buildTurnRequest(record, turnId, message, isFirstTurn, instructionsInvisibleToHarness, emit, eventContext, (update) => __awaiter(this, void 0, void 0, function* () {
+                    const onUpdate = (update) => __awaiter(this, void 0, void 0, function* () {
                         const turn = this.turnRoots.get(sessionId);
                         if (turn !== undefined) {
                             update = yield applyWebScratchUpdate({
@@ -1619,11 +1749,26 @@ export class SessionEngine {
                             yield this.emitDeliveredNudges(record, emit);
                             yield yieldEventLoop();
                         }
-                    }), signal, pendingImages);
+                    });
+                    const request = yield this.buildTurnRequest(record, turnId, message, isFirstTurn, emit, eventContext, onUpdate, signal, pendingImages);
                     this.activeToolContexts.set(sessionId, { record, turnId, emit });
                     this.stubbedCallIds.set(sessionId, stubbed);
                     try {
                         outcome = yield 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 = yield this.settleAuthoredResult({
+                            record,
+                            turnId,
+                            emit,
+                            eventContext,
+                            turnChannelState,
+                            harnessCwd,
+                            signal,
+                            onUpdate,
+                            mapper,
+                            outcome,
+                        });
                     }
                     finally {
                         this.activeToolContexts.delete(sessionId);
@@ -1654,47 +1799,22 @@ export class SessionEngine {
             mapper.finish();
             if (mapper.title !== undefined) {
                 const title = mapper.title;
-                yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { title })));
+                yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { title })));
                 eventContext.session = Object.assign(Object.assign({}, eventContext.session), { title });
             }
-            const finalResult = (_c = outcome.result) !== null && _c !== void 0 ? _c : mapper.finalText;
-            const finalUsage = (_d = outcome.usage) !== null && _d !== void 0 ? _d : mapper.usage;
+            const finalResult = (_d = outcome.result) !== null && _d !== void 0 ? _d : mapper.finalText;
+            const finalUsage = (_e = outcome.usage) !== null && _e !== void 0 ? _e : mapper.usage;
             const finalCost = finalUsage === undefined
                 ? undefined
                 : yield this.estimateTurnCost({
-                    model: (_e = this.project.agent.model) !== null && _e !== void 0 ? _e : DEFAULT_MODEL,
+                    model: (_f = this.project.agent.model) !== null && _f !== void 0 ? _f : DEFAULT_MODEL,
                     usage: finalUsage,
                     agentId: record.sdkAgentId,
-                    conversationId: (_f = record.sdkAgentId) !== null && _f !== void 0 ? _f : sessionId,
+                    conversationId: (_g = record.sdkAgentId) !== null && _g !== void 0 ? _g : sessionId,
                 });
             if (finalCost !== undefined) {
                 outcome = Object.assign(Object.assign({}, outcome), { cost: finalCost });
             }
-            const authored = this.project.result;
-            if (outcome.status === "finished" && authored !== undefined) {
-                const settled = yield 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") {
                 yield this.appendEvent(sessionId, {
                     type: "turn.completed",
@@ -1715,21 +1835,21 @@ export class SessionEngine {
                         status: outcome.status,
                         message: interrupted
                             ? "turn interrupted"
-                            : ((_g = outcome.errorMessage) !== null && _g !== void 0 ? _g : (outcome.status === "cancelled"
+                            : ((_h = outcome.errorMessage) !== null && _h !== void 0 ? _h : (outcome.status === "cancelled"
                                 ? "turn cancelled"
                                 : "turn failed")),
                     },
                 }, eventContext);
             }
             const current = yield this.sessions.get(sessionId);
-            const mode = (_h = current === null || current === void 0 ? void 0 : current.mode) !== null && _h !== void 0 ? _h : record.mode;
+            const mode = (_j = current === null || current === void 0 ? void 0 : current.mode) !== null && _j !== void 0 ? _j : record.mode;
             if (mode === "task") {
                 yield this.appendEvent(sessionId, outcome.status === "finished"
                     ? { type: "session.completed", turnId, data: {} }
                     : {
                         type: "session.failed",
                         turnId,
-                        data: { message: (_j = outcome.errorMessage) !== null && _j !== void 0 ? _j : "task failed" },
+                        data: { message: (_k = outcome.errorMessage) !== null && _k !== void 0 ? _k : "task failed" },
                     }, eventContext);
                 yield this.wipeCloudSessionWorkspace(sessionId);
             }
@@ -1743,6 +1863,65 @@ export class SessionEngine {
             return Object.assign(Object.assign({}, outcome), { result: finalResult, usage: finalUsage });
         });
     }
+    /**
+     * 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.
+     */
+    settleAuthoredResult(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            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 = yield applyAuthoredResult({
+                    definition: authored,
+                    text: (_a = outcome.result) !== null && _a !== void 0 ? _a : 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 Object.assign(Object.assign({}, 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 = yield this.buildTurnRequest(args.record, args.turnId, resultRepairPrompt(settled.message), false, args.emit, args.eventContext, args.onUpdate, args.signal);
+                const repaired = yield this.runTurnExecute(args.record, args.turnId, () => this.runner.runTurn(repairRequest));
+                usage = addTurnUsage(usage, repaired.usage);
+                if (repaired.status !== "finished") {
+                    return Object.assign(Object.assign({}, repaired), { usage });
+                }
+                outcome = Object.assign(Object.assign({}, repaired), { usage });
+            }
+        });
+    }
     /**
      * Sync authored skills onto the Agent Store at `skills/<name>/…` (hosted)
      * or `agent-serve/<agent>/skills/<name>/…` (personal-key local+cloud)
@@ -1821,7 +2000,7 @@ export class SessionEngine {
     }
     clearPendingWorkspaceFiles(sessionId, pending) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { pendingWorkspaceFiles: current.pendingWorkspaceFiles === pending
+            yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { pendingWorkspaceFiles: current.pendingWorkspaceFiles === pending
                     ? undefined
                     : current.pendingWorkspaceFiles })));
         });
@@ -1843,7 +2022,7 @@ export class SessionEngine {
         if (inFlight !== undefined) {
             return inFlight;
         }
-        let sync = run().then(() => true, (error) => {
+        let sync = run().then(() => true, error => {
             this.logger(`[${surface}] ${store.label} sync failed: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         });
@@ -1858,11 +2037,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.
      */
     cloudStore() {
         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(),
@@ -1892,7 +2077,7 @@ export class SessionEngine {
         }
         return undefined;
     }
-    buildTurnRequest(record, turnId, prompt, isFirstTurn, instructionsInvisibleToHarness, emit, eventContext, onUpdate, signal, images) {
+    buildTurnRequest(record, turnId, prompt, isFirstTurn, emit, eventContext, onUpdate, signal, images) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             var _d;
@@ -1926,7 +2111,7 @@ export class SessionEngine {
             // per-session tools or identity is worse than a refused one. Non-local
             // agents already fail discovery; this guards hybrid agents' per-send
             // cloud sessions.
-            const perSessionConnection = agent.connections.find((connection) => connection.advertiseTools === true || connection.auth !== undefined);
+            const perSessionConnection = agent.connections.find(connection => connection.advertiseTools === true || connection.auth !== undefined);
             if (runtime !== "local" && perSessionConnection !== undefined) {
                 throw new Error(`Agent "${agent.name}" connection "${perSessionConnection.name}" uses advertiseTools/auth, which only run on local turns. Refusing the session rather than running it without the connection's tools or identity.`);
             }
@@ -1967,7 +2152,7 @@ export class SessionEngine {
                 ? []
                 : this.withTurnScratchTools(authoredRoot
                     ? fileTools
-                    : fileTools.filter((tool) => tool.name !== "SemanticSearch"), record.sessionId);
+                    : fileTools.filter(tool => tool.name !== "SemanticSearch"), record.sessionId);
             let turnPrompt = prompt;
             if (isFirstTurn) {
                 const contextBlock = buildSessionContextBlock({
@@ -2029,6 +2214,7 @@ 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(", ")}`);
                     yield this.clearPendingWorkspaceFiles(record.sessionId, pending);
                 }
                 if (isFirstTurn && hosted) {
@@ -2036,33 +2222,23 @@ 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(Object.assign(Object.assign({}, 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(Object.assign(Object.assign({}, agent), { tools: [...agent.tools, ...synthesized] }), { includeScripts: true })
+                    : buildAgentsMdContent(agent, {
+                        includeScripts: this.hasBorrowedWorkspace(record),
+                    })
+                : undefined;
             return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ sessionId: record.sessionId }, (record.sdkAgentId === undefined
                 ? {}
                 : { sdkAgentId: record.sdkAgentId })), { workspaceDir: this.harnessCwd(record), sandbox: authoredRoot ? false : ((_c = agent.local) === null || _c === void 0 ? void 0 : _c.sandbox) === true }), (runtime === "local" && harnessTools !== undefined
@@ -2071,30 +2247,35 @@ export class SessionEngine {
                     : { tools: harnessTools.tools })), (harnessTools.disallowedTools === undefined
                     ? {}
                     : { disallowedTools: harnessTools.disallowedTools })) : {})), { runnerStateDir: join(this.stateRoot, "runner"), prompt: turnPrompt, isFirstTurn }), (images !== undefined && images.length > 0 ? { images } : {})), (agent.model === undefined ? {} : { model: agent.model })), { 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 }), (runtime === "cloud" && !isCursorHostedFilesAvailable()
+                    : localInstructions }), (runtime === "cloud" && !isCursorHostedFilesAvailable()
                 ? { agentServeAgent: this.project.name }
                 : {})), { customTools: runtime === "local"
                     ? yield this.buildCustomTools(record, turnId, emit, synthesized)
-                    : {}, mcpServers: this.buildMcpServers(runtime, record.sessionId, yield this.evaluateConnectionAuth(record)) }), (runtime === "local" && this.hasAttachedAuthedConnections()
+                    : {}, mcpServers: this.buildMcpServers(runtime, record.sessionId, yield this.evaluateConnectionAuth(record)) }), (runtime === "local" &&
+                (this.hasAttachedAuthedConnections() ||
+                    this.project.agent.connections.some(connection => isCursorAccountTransport(connection.transport)))
                 ? { perSendMcpServers: true }
                 : {})), { subagents: buildRunnerSubagents(agent), onUpdate,
                 signal, 
                 // 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) => {
+                forceExpireActiveRun: runtime === "local" && !isFirstTurn, onRequestId: requestId => {
                     emit({ type: "turn.bound", data: { requestId } });
                 }, onSdkAgentId: (sdkAgentId) => __awaiter(this, void 0, void 0, function* () {
                     if (record.sdkAgentId === sdkAgentId) {
                         return;
                     }
-                    yield this.updateRecord(record.sessionId, (current) => (Object.assign(Object.assign({}, current), { sdkAgentId })));
+                    yield this.updateRecord(record.sessionId, current => (Object.assign(Object.assign({}, current), { sdkAgentId })));
                     record.sdkAgentId = sdkAgentId;
                     eventContext.session = Object.assign(Object.assign({}, eventContext.session), { sdkAgentId });
                     yield this.appendEvent(record.sessionId, {
@@ -2173,9 +2354,9 @@ export class SessionEngine {
         // Advertised connections surface as named server tools instead of an
         // 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));
-        const hostConnectionNames = new Set(((_a = this.project.agent.hostConnections) !== null && _a !== void 0 ? _a : []).map((connection) => connection.name));
+            .filter(connection => connection.advertiseTools === true)
+            .map(connection => connection.name));
+        const hostConnectionNames = new Set(((_a = this.project.agent.hostConnections) !== null && _a !== void 0 ? _a : []).map(connection => connection.name));
         const bridgedNames = new Set(runtime === "cloud" &&
             sessionId !== undefined &&
             this.cloudServerToolsConnection !== undefined &&
@@ -2184,7 +2365,7 @@ export class SessionEngine {
             : []);
         assertCloudCanHonorAccountServersFilters({
             runtime,
-            resolvedConnections: this.resolvedConnections.filter((resolved) => !advertisedNames.has(resolved.name) &&
+            resolvedConnections: this.resolvedConnections.filter(resolved => !advertisedNames.has(resolved.name) &&
                 !hostConnectionNames.has(resolved.name)),
             bridgedNames,
         });
@@ -2245,6 +2426,18 @@ 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,
@@ -2253,7 +2446,7 @@ export class SessionEngine {
         if (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(`MCP connection name "${SERVER_TOOLS_MCP_SERVER_NAME}" is reserved for authored server tools on cloud turns.`);
             }
@@ -2273,7 +2466,7 @@ export class SessionEngine {
      * ride every send instead of being pinned on the cached agent handle.
      */
     hasAttachedAuthedConnections() {
-        return this.project.agent.connections.some((connection) => connection.auth !== undefined && connection.advertiseTools !== true);
+        return this.project.agent.connections.some(connection => connection.auth !== undefined && connection.advertiseTools !== true);
     }
     /**
      * Evaluate per-session connection auth (`defineConnection({ auth })`)
@@ -2284,7 +2477,7 @@ export class SessionEngine {
      */
     evaluateConnectionAuth(record) {
         return __awaiter(this, void 0, void 0, function* () {
-            const authed = this.project.agent.connections.filter((connection) => connection.auth !== undefined && connection.advertiseTools !== true);
+            const authed = this.project.agent.connections.filter(connection => connection.auth !== undefined && connection.advertiseTools !== true);
             if (authed.length === 0) {
                 return undefined;
             }
@@ -2372,7 +2565,7 @@ export class SessionEngine {
             if (active === undefined) {
                 return toolErrorResult(`Session ${sessionId} has no active turn for tool "${toolName}".`);
             }
-            const tool = this.project.agent.tools.find((candidate) => candidate.name === toolName && candidate.execution === "server");
+            const tool = this.project.agent.tools.find(candidate => candidate.name === toolName && candidate.execution === "server");
             if (tool === undefined) {
                 return toolErrorResult(`Unknown server tool "${toolName}".`);
             }
@@ -2526,8 +2719,8 @@ export class SessionEngine {
                 requestedAt,
             };
             const resolutionPromise = this.approvals.wait(args.sessionId, pendingRecord);
-            yield this.updateRecord(args.sessionId, (current) => { var _a; return (Object.assign(Object.assign({}, current), { pendingApprovals: [
-                    ...((_a = current.pendingApprovals) !== null && _a !== void 0 ? _a : []).filter((item) => item.callId !== args.callId),
+            yield this.updateRecord(args.sessionId, current => { var _a; return (Object.assign(Object.assign({}, current), { pendingApprovals: [
+                    ...((_a = current.pendingApprovals) !== null && _a !== void 0 ? _a : []).filter(item => item.callId !== args.callId),
                     pendingRecord,
                 ] })); });
             args.emit({
@@ -2540,7 +2733,7 @@ export class SessionEngine {
             });
             this.logger(`[session] tool ${args.toolName} awaiting approval (${args.callId})`);
             const { decision, by } = yield resolutionPromise;
-            yield this.updateRecord(args.sessionId, (current) => { var _a; return (Object.assign(Object.assign({}, current), { pendingApprovals: ((_a = current.pendingApprovals) !== null && _a !== void 0 ? _a : []).filter((item) => item.callId !== args.callId) })); });
+            yield this.updateRecord(args.sessionId, current => { var _a; return (Object.assign(Object.assign({}, current), { pendingApprovals: ((_a = current.pendingApprovals) !== null && _a !== void 0 ? _a : []).filter(item => item.callId !== args.callId) })); });
             args.emit({
                 type: "action.approval_resolved",
                 data: Object.assign({ callId: args.callId, toolName: args.toolName, decision }, (by === undefined ? {} : { by })),
@@ -2557,7 +2750,7 @@ export class SessionEngine {
                 current.pendingApprovals.length === 0) {
                 return;
             }
-            yield this.updateRecord(sessionId, (record) => (Object.assign(Object.assign({}, record), { pendingApprovals: [] })));
+            yield this.updateRecord(sessionId, record => (Object.assign(Object.assign({}, record), { pendingApprovals: [] })));
         });
     }
     /** Pending tool approvals for a session (live waiters ∪ persisted). */
@@ -2594,7 +2787,7 @@ export class SessionEngine {
             if (!samePrincipal(record.auth, ownershipAuth)) {
                 throw new SessionAuthError(sessionId);
             }
-            const pending = (_b = ((_a = record.pendingApprovals) !== null && _a !== void 0 ? _a : []).find((item) => item.callId === callId)) !== null && _b !== void 0 ? _b : this.approvals.list(sessionId).find((item) => item.callId === callId);
+            const pending = (_b = ((_a = record.pendingApprovals) !== null && _a !== void 0 ? _a : []).find(item => item.callId === callId)) !== null && _b !== void 0 ? _b : this.approvals.list(sessionId).find(item => item.callId === callId);
             if (pending === undefined) {
                 throw new ApprovalNotFoundError(sessionId, callId);
             }
@@ -2608,21 +2801,21 @@ export class SessionEngine {
     }
     removePendingApproval(sessionId, callId) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateRecord(sessionId, (current) => { var _a; return (Object.assign(Object.assign({}, current), { pendingApprovals: ((_a = current.pendingApprovals) !== null && _a !== void 0 ? _a : []).filter((item) => item.callId !== callId) })); });
+            yield this.updateRecord(sessionId, current => { var _a; return (Object.assign(Object.assign({}, current), { pendingApprovals: ((_a = current.pendingApprovals) !== null && _a !== void 0 ? _a : []).filter(item => item.callId !== callId) })); });
         });
     }
     wrapMcp(inner) {
         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)),
         };
     }
     advertiseMcp() {
         return {
-            listTools: (name) => this.withMcpListAuth(name, () => this.mcpHost.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: () => this.withMcpListAuth(connection.name, () => inner.listTools()),
@@ -2743,8 +2936,8 @@ export class SessionEngine {
                 requestedAt,
             };
             const resolutionPromise = this.auths.wait(args.sessionId, pendingRecord);
-            yield this.updateRecord(args.sessionId, (current) => { var _a; return (Object.assign(Object.assign({}, current), { pendingAuths: [
-                    ...((_a = current.pendingAuths) !== null && _a !== void 0 ? _a : []).filter((item) => item.callId !== args.callId),
+            yield this.updateRecord(args.sessionId, current => { var _a; return (Object.assign(Object.assign({}, current), { pendingAuths: [
+                    ...((_a = current.pendingAuths) !== null && _a !== void 0 ? _a : []).filter(item => item.callId !== args.callId),
                     pendingRecord,
                 ] })); });
             args.emit({
@@ -2758,7 +2951,7 @@ export class SessionEngine {
             });
             this.logger(`[session] tool ${args.toolName} awaiting MCP auth ${args.connection} (${args.callId})`);
             const { decision, by } = yield resolutionPromise;
-            yield this.updateRecord(args.sessionId, (current) => { var _a; return (Object.assign(Object.assign({}, current), { pendingAuths: ((_a = current.pendingAuths) !== null && _a !== void 0 ? _a : []).filter((item) => item.callId !== args.callId) })); });
+            yield this.updateRecord(args.sessionId, current => { var _a; return (Object.assign(Object.assign({}, current), { pendingAuths: ((_a = current.pendingAuths) !== null && _a !== void 0 ? _a : []).filter(item => item.callId !== args.callId) })); });
             args.emit({
                 type: "action.auth_resolved",
                 data: {
@@ -2782,7 +2975,7 @@ export class SessionEngine {
                 current.pendingAuths.length === 0) {
                 return;
             }
-            yield this.updateRecord(sessionId, (record) => (Object.assign(Object.assign({}, record), { pendingAuths: [] })));
+            yield this.updateRecord(sessionId, record => (Object.assign(Object.assign({}, record), { pendingAuths: [] })));
         });
     }
     listPendingAuths(sessionId) {
@@ -2810,7 +3003,7 @@ export class SessionEngine {
             if (!samePrincipal(record.auth, ownershipAuth)) {
                 throw new SessionAuthError(sessionId);
             }
-            const pending = (_b = ((_a = record.pendingAuths) !== null && _a !== void 0 ? _a : []).find((item) => item.callId === callId)) !== null && _b !== void 0 ? _b : this.auths.list(sessionId).find((item) => item.callId === callId);
+            const pending = (_b = ((_a = record.pendingAuths) !== null && _a !== void 0 ? _a : []).find(item => item.callId === callId)) !== null && _b !== void 0 ? _b : this.auths.list(sessionId).find(item => item.callId === callId);
             if (pending === undefined) {
                 throw new AuthNotFoundError(sessionId, callId);
             }
@@ -2827,7 +3020,7 @@ export class SessionEngine {
     }
     removePendingAuth(sessionId, callId) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateRecord(sessionId, (current) => { var _a; return (Object.assign(Object.assign({}, current), { pendingAuths: ((_a = current.pendingAuths) !== null && _a !== void 0 ? _a : []).filter((item) => item.callId !== callId) })); });
+            yield this.updateRecord(sessionId, current => { var _a; return (Object.assign(Object.assign({}, current), { pendingAuths: ((_a = current.pendingAuths) !== null && _a !== void 0 ? _a : []).filter(item => item.callId !== callId) })); });
         });
     }
     runWithMcpPark(sessionId, toolName, fn) {
@@ -2977,16 +3170,16 @@ export class SessionEngine {
      */
     describeCatalogTool(toolName_1) {
         return __awaiter(this, arguments, void 0, function* (toolName, options = {}) {
-            const authored = this.project.agent.tools.find((tool) => tool.name === toolName);
+            const authored = this.project.agent.tools.find(tool => tool.name === toolName);
             if (authored !== undefined) {
                 return { tool: authored };
             }
             const catalog = yield 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,
                 };
             }
@@ -3024,9 +3217,9 @@ 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
                 // the same model-facing name a turn would. A listing failure fails
@@ -3036,12 +3229,12 @@ 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;
             if (tool.execution !== "server" || typeof execute !== "function") {
@@ -3320,7 +3513,7 @@ export class SessionEngine {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const listed = yield this.host.mcp.listTools(connectionName);
-                return listed.find((tool) => tool.name === toolName);
+                return listed.find(tool => tool.name === toolName);
             }
             catch (_a) {
                 return undefined;
@@ -3347,7 +3540,7 @@ export class SessionEngine {
         const chain = (_b = this.dispatchChains.get(sessionId)) !== null && _b !== void 0 ? _b : 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)}`);
         })
             .then(() => {
@@ -3406,12 +3599,12 @@ export class SessionEngine {
                 }
                 if (context === undefined || channelStateBefore === undefined) {
                     // Handlers mutate live channel state in place; save the current record.
-                    yield this.updateRecord(sessionId, (current) => (Object.assign({}, current)));
+                    yield this.updateRecord(sessionId, current => (Object.assign({}, current)));
                 }
                 else {
                     const updatedState = channelCtx.state;
                     context.channelState = updatedState;
-                    yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { channelState: mergeChannelStateMutation({
+                    yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { channelState: mergeChannelStateMutation({
                             current: current.channelState,
                             before: channelStateBefore,
                             after: updatedState,
@@ -3484,8 +3677,10 @@ export class SessionEngine {
             var _a;
             // 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;
             for (;;) {
                 const chain = this.admissionChains.get(sessionId);
                 if (chain !== undefined) {
@@ -3493,14 +3688,15 @@ export class SessionEngine {
                 }
                 const active = this.activeTurns.get(sessionId);
                 if (active !== undefined) {
-                    yield active;
+                    const outcome = yield active;
+                    root !== null && root !== void 0 ? root : (root = outcome);
                     continue;
                 }
                 const dispatch = this.dispatchChains.get(sessionId);
                 if (dispatch !== undefined) {
                     yield dispatch.catch(() => { });
                 }
-                return (_a = this.lastOutcomes.get(sessionId)) !== null && _a !== void 0 ? _a : { status: "finished" };
+                return (_a = root !== null && root !== void 0 ? root : this.lastOutcomes.get(sessionId)) !== null && _a !== void 0 ? _a : { status: "finished" };
             }
         });
     }
@@ -3534,7 +3730,7 @@ export class SessionEngine {
                 return records;
             }
             const owned = yield this.ownedSessionIds(caller);
-            return records.filter((record) => record.sessionId !== undefined && owned.has(record.sessionId));
+            return records.filter(record => record.sessionId !== undefined && owned.has(record.sessionId));
         });
     }
     /**
@@ -3565,8 +3761,8 @@ export class SessionEngine {
         return __awaiter(this, void 0, void 0, function* () {
             const sessions = yield 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));
         });
     }
     /**
@@ -3686,8 +3882,8 @@ export class SessionEngine {
     }
     summarizeSessionRecords(records, caller, includeAll) {
         return records
-            .filter((record) => includeAll || samePrincipal(record.auth, caller))
-            .map((record) => {
+            .filter(record => includeAll || samePrincipal(record.auth, caller))
+            .map(record => {
             var _a;
             const links = sessionExternalLinks(record);
             return {
@@ -3737,7 +3933,7 @@ export class SessionEngine {
             if (existing === undefined) {
                 throw new Error(`Unknown session: ${sessionId}`);
             }
-            const record = yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { turnCount: current.turnCount + 1 })));
+            const record = yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { turnCount: current.turnCount + 1 })));
             const turnId = `turn_${record.turnCount}`;
             yield this.appendEvent(sessionId, {
                 type: "turn.started",
@@ -3852,7 +4048,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)}`);
         })
             .finally(() => {
@@ -3867,9 +4063,9 @@ export class SessionEngine {
             var _b, _c;
             const log = yield this.logs.get(sessionId);
             const events = yield 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);
                 }
                 return;
@@ -3896,7 +4092,7 @@ export class SessionEngine {
                 }
                 log.replace(i, next);
             }
-            if (!(yield log.snapshot(0)).some((event) => isUnpricedCompletedTurn(event))) {
+            if (!(yield log.snapshot(0)).some(event => isUnpricedCompletedTurn(event))) {
                 this.cloudCostBackfillDone.add(sessionId);
             }
         });
@@ -3905,7 +4101,7 @@ export class SessionEngine {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const previous = yield this.sessions.get(sessionId);
-            yield this.updateRecord(sessionId, (current) => (Object.assign(Object.assign({}, current), { continuationKey: token })));
+            yield this.updateRecord(sessionId, current => (Object.assign(Object.assign({}, current), { continuationKey: token })));
             // Keep armed reminders addressed at the conversation across channel
             // continuation rotation.
             if ((previous === null || previous === void 0 ? void 0 : previous.continuationKey) != null &&
@@ -4020,7 +4216,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)
@@ -4256,7 +4452,7 @@ function eventsNdjson(events) {
     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) {
     var _a;
@@ -4271,7 +4467,7 @@ function subagentPrompt(subagent) {
  * executor that turn will run on.
  */
 function buildRunnerSubagents(agent) {
-    return agent.subagents.map((subagent) => { var _a; return (Object.assign({ name: subagent.name, description: (_a = subagent.description) !== null && _a !== void 0 ? _a : subagent.name, prompt: subagentPrompt(subagent) }, (subagent.model === undefined ? {} : { model: subagent.model }))); });
+    return agent.subagents.map(subagent => { var _a; return (Object.assign({ name: subagent.name, description: (_a = subagent.description) !== null && _a !== void 0 ? _a : subagent.name, prompt: subagentPrompt(subagent) }, (subagent.model === undefined ? {} : { model: subagent.model }))); });
 }
 function toolErrorResult(message) {
     return {
@@ -4287,7 +4483,7 @@ function defaultGetCloudUsage(sdkAgentId) {
             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,
@@ -4333,7 +4529,7 @@ function approvalResolverLabel(auth) {
 }
 /** Let the HTTP NDJSON writer flush before the next SDK update. */
 function yieldEventLoop() {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
         setImmediate(resolve);
     });
 }