@agent-native/core 0.214.0 → 0.217.0

package/dist/agent/run-manager.js

@@ -12,7 +12,7 @@ import { getAgentEngineEntry } from "./engine/registry.js";
 import { EngineError } from "./engine/types.js";
 import { currentExecutionFence, MissingExecutionFenceError, StaleExecutionFenceError, withExecutionFence, withExecutionLeaseRequested, } from "./execution-fence.js";
 import { AgentRunEventNotPersistedError, insertRun, insertRunEvent, insertRunEvents, updateRunStatusIfRunning, markRunAborted, markRunAbortedAtSafeBoundary, getRunAbortState, getRunStatus, getRunEventsSince, getCurrentTurnRunEventsForThread, getRunById, getRunByThread, getRunTurnRef, listRunsForThread, markTurnAborted, cleanupOldRuns, updateRunHeartbeat, bumpRunProgress, setRunInFlightMarker, reapIfStale, reapUnclaimedBackgroundRun, shouldRedispatchUnclaimedBackgroundRun, reconcileTerminalRunFromEvents, ensureTerminalRunEvent, getLastTerminalRunEvent, resolveErroredRunTerminalEvent, setRunError, setRunTerminalReason, persistRunCheckpointEvent, recordRunDiagnostic, RUN_DIAG_STAGE, claimTurnExecutionLease, renewTurnExecutionLease, releaseTurnExecutionLease, TurnExecutionLeaseBusyError, terminalEventForAbortReason, RUN_RECORD_MISSING_ERROR_EVENT, RUN_RECORD_MISSING_GRACE_MS, RUN_TERMINAL_LOOKUP_FAILED_ERROR_EVENT, UNKNOWN_RUN_STATUS_ERROR_EVENT, } from "./run-store.js";
-import { isContinuationTerminalReason } from "./types.js";
+import { CONTINUATION_REASONS, isContinuationTerminalReason } from "./types.js";
 const activeRuns = new Map();
 const threadToRun = new Map();
 function peekRunEventSeq(run) {
@@ -107,6 +107,13 @@ const RECONNECTABLE_TERMINAL_RUN_STATUSES = new Set([
     "errored",
     "aborted",
 ]);
+function isKnownRunStatus(status) {
+    return (status === "running" ||
+        status === "completed" ||
+        status === "truncated" ||
+        status === "errored" ||
+        status === "aborted");
+}
 function isDuplicateSubmissionMarker(run) {
     return (run.status === "aborted" &&
         run.terminalReason === "aborted:duplicate_submission");
@@ -371,6 +378,8 @@ function terminalReasonForRun(finalStatus, terminalEvent, abortReason, completio
     if (terminalEvent?.type === "error") {
         return `error:${terminalEvent.errorCode || "unknown"}`;
     }
+    if (finalStatus === "truncated")
+        return "stream_ended";
     if (finalStatus === "aborted")
         return `aborted:${abortReason ?? "user"}`;
     if (completionError)
@@ -584,6 +593,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         },
     };
     let softTimedOut = false;
+    let checkpointBoundaryStarted = false;
     let resolveFinalized = () => { };
     let rejectFinalized = () => { };
     const finalized = new Promise((resolve, reject) => {
@@ -652,12 +662,16 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         : undefined;
     const servicePrincipalRunStart = Boolean(options?.turnInitiator &&
         parseServiceIdentityEmail(options.turnInitiator.email));
+    let servicePrincipalStartRefused = false;
     const insertRunPromise = (options?.runRowAlreadyInserted && !servicePrincipalRunStart
         ? Promise.resolve()
         : insertOptions
             ? insertRun(runId, threadId, options?.turnId, insertOptions)
             : insertRun(runId, threadId, options?.turnId)).catch((error) => {
         captureRunPersistenceError(error, "insert-run");
+        if (error instanceof ServicePrincipalRefusedError) {
+            servicePrincipalStartRefused = true;
+        }
         if (options?.executionLease ||
             error instanceof ServicePrincipalRefusedError)
             throw error;
@@ -983,24 +997,140 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             mirrorInFlightMarker(false);
         }
     };
+    let checkpointRunBoundaryTask = Promise.resolve();
     let checkpointAbortInFlight = false;
-    const checkpointRunBoundary = async (event, terminalReason) => {
+    let checkpointPersistenceFailed = false;
+    let checkpointStatusReadFailed = false;
+    let checkpointUnknownStatus = null;
+    let checkpointObservedTerminalStatus = null;
+    const observeCheckpointRunStatus = (persistedRun, context) => {
+        if (!persistedRun) {
+            checkpointStatusReadFailed = true;
+            console.error(`[run-manager] run row missing ${context}`, runId);
+            return "missing";
+        }
+        if (!isKnownRunStatus(persistedRun.status)) {
+            checkpointUnknownStatus = persistedRun.status;
+            return "unknown";
+        }
+        if (persistedRun.status === "running")
+            return "running";
+        checkpointObservedTerminalStatus = persistedRun.status;
+        run.status = persistedRun.status;
+        if (persistedRun.status === "aborted") {
+            run.abortReason = persistedRun.terminalReason?.startsWith("aborted:")
+                ? persistedRun.terminalReason.slice("aborted:".length)
+                : undefined;
+        }
+        return "terminal";
+    };
+    let runDriverSettled = false;
+    let pendingTerminalEvent = null;
+    let persistedCheckpointTerminalEvent = null;
+    const rememberPersistedCheckpointTerminalEvent = (persistedRun, checkpointEvent) => {
+        if (persistedRun?.status !== "truncated")
+            return;
+        const persistedReason = persistedRun.terminalReason;
+        const persistedContinuationReason = CONTINUATION_REASONS.find((reason) => reason === persistedReason);
+        const reason = persistedContinuationReason ??
+            (checkpointEvent.type === "auto_continue"
+                ? checkpointEvent.reason
+                : "stream_ended");
+        persistedCheckpointTerminalEvent = {
+            seq: peekRunEventSeq(run),
+            event: { type: "auto_continue", reason },
+        };
+    };
+    const checkpointRunBoundary = (event, terminalReason, diagnostic) => {
         if (checkpointAbortInFlight ||
             run.status !== "running" ||
             abort.signal.aborted)
-            return;
+            return checkpointRunBoundaryTask;
         checkpointAbortInFlight = true;
-        try {
-            await withWorkerFence(() => persistRunCheckpointEvent(runId, event, terminalReason));
-        }
-        catch {
-            // The abort still has to happen if the checkpoint write is rejected; the
-            // caller has already reached a server-owned chunk boundary.
-        }
-        finally {
-            abort.abort(terminalReason);
-            checkpointAbortInFlight = false;
-        }
+        checkpointBoundaryStarted = true;
+        const task = (async () => {
+            let checkpointPersisted = false;
+            try {
+                await withWorkerFence(() => persistRunCheckpointEvent(runId, event, terminalReason));
+                checkpointPersisted = true;
+                let persistedRun;
+                try {
+                    persistedRun = await getRunById(runId);
+                }
+                catch (error) {
+                    checkpointStatusReadFailed = true;
+                    console.error("[run-manager] could not confirm run status after checkpoint persistence", runId, error instanceof Error ? error.message : error);
+                    return;
+                }
+                const checkpointStatus = observeCheckpointRunStatus(persistedRun, "after checkpoint persistence");
+                if (checkpointStatus !== "running") {
+                    rememberPersistedCheckpointTerminalEvent(persistedRun, event);
+                    return;
+                }
+                softTimedOut = true;
+                recordRunBoundaryDiagnostic(terminalReason, diagnostic, "terminal");
+                emitRunBoundaryTrackingEvent({
+                    runId,
+                    threadId,
+                    reason: terminalReason,
+                    recovered: false,
+                    boundaryIndex: recoveredChunkBoundaries + 1,
+                    dispatchMode: options?.dispatchMode,
+                    model: options?.model,
+                    engineName: options?.engineName,
+                    userId: options?.userId,
+                });
+                if (!pendingTerminalEvent && run.status === "running") {
+                    send(event);
+                    persistedCheckpointTerminalEvent = pendingTerminalEvent;
+                }
+            }
+            catch (error) {
+                let persistedCheckpointStatus = "running";
+                if (error instanceof AgentRunEventNotPersistedError &&
+                    error.terminalRun) {
+                    try {
+                        const persistedRun = await getRunById(runId);
+                        persistedCheckpointStatus = observeCheckpointRunStatus(persistedRun, "after checkpoint rejection");
+                        rememberPersistedCheckpointTerminalEvent(persistedRun, event);
+                    }
+                    catch (statusError) {
+                        checkpointStatusReadFailed = true;
+                        console.error("[run-manager] could not confirm run status after checkpoint rejection", runId, statusError instanceof Error ? statusError.message : statusError);
+                    }
+                }
+                if (!checkpointStatusReadFailed &&
+                    (persistedCheckpointStatus === "terminal" ||
+                        (pendingTerminalEvent && !checkpointPersisted))) {
+                    softTimedOut = true;
+                }
+                else if (!checkpointStatusReadFailed &&
+                    persistedCheckpointStatus !== "unknown") {
+                    checkpointPersistenceFailed = true;
+                }
+                if (persistedCheckpointStatus !== "terminal" &&
+                    persistedCheckpointStatus !== "unknown" &&
+                    !checkpointStatusReadFailed) {
+                    console.error("[run-manager] could not persist run boundary checkpoint", runId, error instanceof Error ? error.message : error);
+                }
+                if (!pendingTerminalEvent &&
+                    persistedCheckpointStatus !== "terminal" &&
+                    persistedCheckpointStatus !== "unknown" &&
+                    !checkpointStatusReadFailed) {
+                    send({
+                        type: "error",
+                        error: "The agent could not save its continuation checkpoint.",
+                        errorCode: "run_checkpoint_persistence_failed",
+                    });
+                }
+            }
+            finally {
+                abort.abort(run.abortReason ?? terminalReason);
+                checkpointAbortInFlight = false;
+            }
+        })();
+        checkpointRunBoundaryTask = task;
+        return task;
     };
     const recordRunBoundaryDiagnostic = (reason, diagnostic, disposition) => {
         if (getCurrentRequestDbPoolScope()?.closing)
@@ -1016,7 +1146,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         })).catch(() => { }))).catch(() => { });
     };
     const reachRunBoundary = (reason, diagnostic = {}) => {
-        if (run.status !== "running" || abort.signal.aborted)
+        if (runDriverSettled || run.status !== "running" || abort.signal.aborted)
             return;
         const activeChunkAbort = chunkAbort;
         const canRecoverChunk = activeChunkAbort !== null &&
@@ -1034,22 +1164,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         }
         if (chunkAbort)
             chunkBoundaryReason = reason;
-        softTimedOut = true;
-        recordRunBoundaryDiagnostic(reason, diagnostic, "terminal");
-        emitRunBoundaryTrackingEvent({
-            runId,
-            threadId,
-            reason,
-            recovered: false,
-            boundaryIndex: recoveredChunkBoundaries + 1,
-            dispatchMode: options?.dispatchMode,
-            model: options?.model,
-            engineName: options?.engineName,
-            userId: options?.userId,
-        });
         const event = { type: "auto_continue", reason };
-        send(event);
-        void checkpointRunBoundary(event, reason);
+        void checkpointRunBoundary(event, reason, diagnostic);
     };
     const checkNoProgressBackstop = () => {
         if (noProgressTimeoutMs <= 0)
@@ -1204,7 +1320,6 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         };
         armChunkSoftTimeout();
     }
-    let pendingTerminalEvent = null;
     const captureRunError = (error, phase) => {
         const errorCode = getRunErrorCode(error);
         const engineError = error instanceof EngineError ? error : null;
@@ -1249,18 +1364,22 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     };
     const persistEventHook = options?.persistEvent;
     const persistRunEvent = async (runEvent, eventData, eventAt) => {
-        if (runEvent.event.type === "tool_start")
+        const terminal = isTerminalRunEvent(runEvent.event);
+        const requireInserted = runEvent.event.type === "tool_start" ||
+            (terminal && !servicePrincipalStartRefused);
+        if (requireInserted)
             await insertRunPromise;
-        const write = () => runEvent.event.type === "tool_start" ||
-            runEvent.event.type === "tool_done"
-            ? insertRunEvent(runId, runEvent.seq, eventData, {
-                eventAt,
-                toolInputSource: "execution",
-                ...(runEvent.event.type === "tool_start"
-                    ? { requireInserted: true }
-                    : {}),
-            })
-            : insertRunEvent(runId, runEvent.seq, eventData, { eventAt });
+        const write = () => insertRunEvent(runId, runEvent.seq, eventData, {
+            eventAt,
+            ...(runEvent.event.type === "tool_start" ||
+                runEvent.event.type === "tool_done"
+                ? { toolInputSource: "execution" }
+                : {}),
+            ...(requireInserted ? { requireInserted: true } : {}),
+            ...(runEvent.event.type === "auto_continue"
+                ? { allowContinuationTerminal: true }
+                : {}),
+        });
         return withWorkerFence(() => options?.persistEvent
             ? options.persistEvent(write, {
                 terminal: isTerminalRunEvent(runEvent.event),
@@ -1381,6 +1500,14 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             event: normalizedEvent,
         };
         if (isTerminalRunEvent(event)) {
+            if (persistedCheckpointTerminalEvent)
+                return Promise.resolve();
+            if (checkpointPersistenceFailed &&
+                pendingTerminalEvent?.event.type === "error" &&
+                pendingTerminalEvent.event.errorCode ===
+                    "run_checkpoint_persistence_failed") {
+                return Promise.resolve();
+            }
             pendingTerminalEvent = runEvent;
             return Promise.resolve();
         }
@@ -1406,18 +1533,40 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         await runFn(send, runControl.chunkSignal, runControl);
     };
     const runPromise = startDriver()
-        .then(() => {
+        .then(async () => {
+        runDriverSettled = true;
+        if (checkpointAbortInFlight)
+            await checkpointRunBoundaryTask;
         settleBoundary(false);
         if (abort.signal.aborted) {
-            run.status = softTimedOut ? "completed" : "aborted";
+            if (run.status !== "aborted") {
+                run.status =
+                    checkpointObservedTerminalStatus ??
+                        (checkpointPersistenceFailed
+                            ? "errored"
+                            : softTimedOut
+                                ? "completed"
+                                : "aborted");
+            }
             return;
         }
         run.status = "completed";
     })
-        .catch((err) => {
+        .catch(async (err) => {
+        runDriverSettled = true;
+        if (checkpointAbortInFlight)
+            await checkpointRunBoundaryTask;
         settleBoundary(false);
         if (abort.signal.aborted) {
-            run.status = softTimedOut ? "completed" : "aborted";
+            if (run.status !== "aborted") {
+                run.status =
+                    checkpointObservedTerminalStatus ??
+                        (checkpointPersistenceFailed
+                            ? "errored"
+                            : softTimedOut
+                                ? "completed"
+                                : "aborted");
+            }
             return;
         }
         run.status = "errored";
@@ -1450,8 +1599,11 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         let eventPersistenceError = null;
         let runTerminalErrorCode;
         let terminalPersistenceEstablished = false;
+        let continuationStatusPersistedBeforeEvent = false;
+        let suppressContinuationEvent = false;
         try {
             await persistenceChain;
+            await run.abortPersistencePromise;
         }
         catch (error) {
             eventPersistenceError = error;
@@ -1467,14 +1619,43 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 };
             }
         }
+        if (checkpointStatusReadFailed || checkpointUnknownStatus !== null) {
+            const event = checkpointStatusReadFailed
+                ? RUN_TERMINAL_LOOKUP_FAILED_ERROR_EVENT
+                : UNKNOWN_RUN_STATUS_ERROR_EVENT;
+            const abortAlreadyWon = run.status === "aborted" && run.abortReason !== undefined;
+            if (!abortAlreadyWon) {
+                run.status = "errored";
+                if (!eventPersistenceError) {
+                    pendingTerminalEvent = {
+                        seq: peekRunEventSeq(run),
+                        event: { ...event },
+                    };
+                }
+            }
+            if (checkpointUnknownStatus !== null) {
+                console.error("[run-manager] checkpoint observed an unknown persisted run status", runId, checkpointUnknownStatus);
+            }
+        }
         const resolveTerminalEventForCompletion = () => {
-            if (run.status === "aborted")
+            if (run.status === "aborted" && run.abortReason !== undefined)
                 return null;
             if (eventPersistenceError) {
                 return pendingTerminalEvent
                     ? { ...pendingTerminalEvent, seq: run.events.length }
                     : null;
             }
+            if (checkpointStatusReadFailed || checkpointUnknownStatus !== null) {
+                return pendingTerminalEvent
+                    ? { ...pendingTerminalEvent, seq: peekRunEventSeq(run) }
+                    : null;
+            }
+            if (persistedCheckpointTerminalEvent) {
+                return {
+                    ...persistedCheckpointTerminalEvent,
+                    seq: peekRunEventSeq(run),
+                };
+            }
             const continuationTerminalEvent = run.continuationTerminalEvent
                 ? {
                     seq: peekRunEventSeq(run),
@@ -1489,7 +1670,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         };
         let terminalEventForCompletion = resolveTerminalEventForCompletion();
         let terminalEvent = terminalEventForCompletion?.event ?? null;
-        if (onComplete) {
+        if (onComplete &&
+            !checkpointStatusReadFailed &&
+            checkpointUnknownStatus === null) {
             try {
                 const completionStatus = run.status !== "aborted" &&
                     terminalEventForcesErroredStatus(terminalEvent)
@@ -1524,9 +1707,13 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 completionError ||
                 terminalEventForcesErroredStatus(terminalEvent)
                 ? "errored"
-                : "completed";
+                : run.status === "truncated"
+                    ? "truncated"
+                    : "completed";
         run.status = finalStatus;
         const shouldAutoContinueAfterUnfinishedTurn = finalStatus === "completed" &&
+            !checkpointStatusReadFailed &&
+            checkpointUnknownStatus === null &&
             (endsAfterToolResultWithoutAssistantFinal(run) ||
                 endsDuringActionPreparation(run)) &&
             (!terminalEventForCompletion ||
@@ -1549,16 +1736,36 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             ? "truncated"
             : finalStatus;
         let volatileTerminalEvent = null;
-        const persistTerminalStatus = () => completionError
-            ? updateRunStatusIfRunning(runId, persistedStatus, {
-                threadProjectionPending: true,
-            })
-            : updateRunStatusIfRunning(runId, persistedStatus);
-        const reconcileTerminalRun = () => completionError
+        const threadProjectionPending = Boolean(completionError ||
+            (onComplete &&
+                (checkpointStatusReadFailed || checkpointUnknownStatus !== null)));
+        const terminalStatusOptions = {
+            ...(threadProjectionPending ? { threadProjectionPending: true } : {}),
+            ...(checkpointBoundaryStarted || persistedStatus === "truncated"
+                ? { terminalReason }
+                : {}),
+        };
+        const persistTerminalStatus = () => Object.keys(terminalStatusOptions).length === 0
+            ? updateRunStatusIfRunning(runId, persistedStatus)
+            : updateRunStatusIfRunning(runId, persistedStatus, terminalStatusOptions);
+        const reconcileTerminalRun = () => threadProjectionPending
             ? reconcileTerminalRunFromEvents(runId, {
                 threadProjectionPending: true,
             })
             : reconcileTerminalRunFromEvents(runId);
+        const reportTerminalStatusPersistenceError = (error) => {
+            captureError(error, {
+                route: "/_agent-native/agent-chat",
+                aiTraceId: runId,
+                tags: {
+                    source: "agent-run-manager",
+                    phase: "terminal-status-persistence",
+                    errorCode: "run_terminal_status_persistence_failed",
+                },
+                extra: { runId, threadId, turnId: run.turnId },
+            });
+            console.error("[run-manager] terminal status persistence error:", error instanceof Error ? error.message : error);
+        };
         if (finalStatus === "completed" || finalStatus === "errored") {
             const terminalEventToEmit = eventPersistenceError
                 ? {
@@ -1581,8 +1788,37 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                                     ? "Agent response could not be saved."
                                     : "Agent run ended unexpectedly",
                             };
+            if (terminalEventToEmit.type === "auto_continue") {
+                if (persistedStatus !== "truncated") {
+                    suppressContinuationEvent = true;
+                }
+                else {
+                    try {
+                        await insertRunPromise;
+                        continuationStatusPersistedBeforeEvent = await withWorkerFence(persistTerminalStatus);
+                        if (!continuationStatusPersistedBeforeEvent) {
+                            await withWorkerFence(reconcileTerminalRun);
+                            const persistedRun = await getRunById(runId);
+                            continuationStatusPersistedBeforeEvent =
+                                persistedRun?.status === "truncated" &&
+                                    persistedRun.terminalReason === terminalReason;
+                        }
+                        if (continuationStatusPersistedBeforeEvent) {
+                            terminalPersistenceEstablished = true;
+                        }
+                        else {
+                            suppressContinuationEvent = true;
+                        }
+                    }
+                    catch (error) {
+                        suppressContinuationEvent = true;
+                        reportTerminalStatusPersistenceError(error);
+                    }
+                }
+            }
             const last = run.events[run.events.length - 1];
-            if (!last || !isTerminalRunEvent(last.event)) {
+            if ((!last || !isTerminalRunEvent(last.event)) &&
+                !suppressContinuationEvent) {
                 const terminal = {
                     seq: terminalEventForCompletion?.seq ?? allocateRunEventSeq(run),
                     event: terminalEventToEmit,
@@ -1621,27 +1857,40 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             if (!executionLeaseClaimFailed)
                 mirrorInFlightMarker(false);
         }
-        const reportTerminalStatusPersistenceError = (error) => {
-            captureError(error, {
-                route: "/_agent-native/agent-chat",
-                aiTraceId: runId,
-                tags: {
-                    source: "agent-run-manager",
-                    phase: "terminal-status-persistence",
-                    errorCode: "run_terminal_status_persistence_failed",
-                },
-                extra: { runId, threadId, turnId: run.turnId },
-            });
-            console.error("[run-manager] terminal status persistence error:", error instanceof Error ? error.message : error);
-        };
-        if (executionLeaseClaimFailed) {
-            await insertRunPromise;
-            await markRunAborted(runId, run.abortReason ?? "execution-lease-claim-failed");
+        if (executionLeaseClaimFailed || finalStatus === "aborted") {
+            if (!executionLeaseClaimFailed && run.abortPersistenceManaged) {
+                terminalPersistenceEstablished = true;
+            }
+            else if (!executionLeaseClaimFailed &&
+                (run.abortReason === "superseded" ||
+                    run.abortReason === "execution_lease_lost")) {
+                terminalPersistenceEstablished = false;
+            }
+            else {
+                try {
+                    await insertRunPromise;
+                    const persistAtomicAbort = () => markRunAborted(runId, run.abortReason ?? "execution-lease-claim-failed");
+                    const aborted = executionLeaseClaimFailed
+                        ? await persistAtomicAbort()
+                        : await withWorkerFence(persistAtomicAbort);
+                    terminalPersistenceEstablished = aborted
+                        ? true
+                        : await withWorkerFence(reconcileTerminalRun);
+                }
+                catch (error) {
+                    terminalPersistenceEstablished = false;
+                    reportTerminalStatusPersistenceError(error);
+                    throw error;
+                }
+            }
         }
         else {
             try {
-                await insertRunPromise;
-                if (!terminalPersistenceError || eventPersistenceError) {
+                if (!continuationStatusPersistedBeforeEvent) {
+                    await insertRunPromise;
+                }
+                if (!continuationStatusPersistedBeforeEvent &&
+                    (!terminalPersistenceError || eventPersistenceError)) {
                     let statusUpdated = false;
                     try {
                         statusUpdated = await withWorkerFence(persistTerminalStatus);
@@ -1650,8 +1899,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                         reportTerminalStatusPersistenceError(error);
                     }
                     if (statusUpdated) {
+                        if (!checkpointBoundaryStarted) {
+                            await withWorkerFence(() => setRunTerminalReason(runId, terminalReason));
+                        }
                         terminalPersistenceEstablished = !terminalPersistenceError;
-                        await withWorkerFence(() => setRunTerminalReason(runId, terminalReason));
                     }
                     else {
                         terminalPersistenceEstablished =
@@ -2102,14 +2353,15 @@ function subscribeFromSQL(runId, fromSeq) {
                                 return;
                             if (run?.status === "aborted") {
                                 const existing = await getLastTerminalRunEvent(runId).catch(() => null);
+                                const persistedTerminal = existing?.event.type === "auto_continue" ? null : existing;
                                 const abortReason = run.terminalReason?.startsWith("aborted:")
                                     ? run.terminalReason.slice("aborted:".length)
                                     : undefined;
-                                const terminalEvent = existing
-                                    ? existing.event
+                                const terminalEvent = persistedTerminal
+                                    ? persistedTerminal.event
                                     : terminalEventForAbortReason(abortReason);
                                 try {
-                                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(streamEventWithIdentity(runId, terminalEvent, existing?.seq ?? lastSeq))}\n\n`));
+                                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(streamEventWithIdentity(runId, terminalEvent, persistedTerminal?.seq ?? lastSeq))}\n\n`));
                                 }
                                 catch {
                                     cancelled = true;
@@ -2497,9 +2749,15 @@ export function abortRun(runId, reason = "user") {
     const run = activeRuns.get(runId);
     const abortedInMemory = abortRunInMemory(runId, reason);
     const markAborted = () => markRunAborted(runId, reason);
-    void flushRunEventsBeforeAbort(run)
+    const abortPersistence = flushRunEventsBeforeAbort(run)
         .then(markAborted, markAborted)
-        .catch((error) => {
+        .then((persisted) => {
+        if (run)
+            run.abortPersistenceManaged = persisted;
+        return persisted;
+    }, (error) => {
+        if (run)
+            run.abortPersistenceManaged = false;
         captureError(error, {
             route: "/_agent-native/agent-chat/runs/:id/abort",
             aiTraceId: runId,
@@ -2507,7 +2765,10 @@ export function abortRun(runId, reason = "user") {
             extra: { runId, threadId: run?.threadId, reason },
         });
         console.error("[run-manager] durable abort status write failed:", error instanceof Error ? error.message : error);
+        return false;
     });
+    if (run)
+        run.abortPersistencePromise = abortPersistence;
     return abortedInMemory;
 }
 /**
@@ -2519,44 +2780,65 @@ export function abortRun(runId, reason = "user") {
 export async function abortRunDurably(runId, reason = "user", options) {
     const run = activeRuns.get(runId);
     const abortedInMemory = abortRunInMemory(runId, reason);
-    try {
-        const eventFlushFailure = await flushRunEventsBeforeAbort(run);
-        const abortPersisted = await markRunAborted(runId, reason);
-        if (!abortPersisted || eventFlushFailure) {
-            const persistedStatus = await getRunStatus(runId);
-            if (persistedStatus === null) {
-                // Agent Teams persists Stop intent before run registration.
-                // Workers recheck it before dispatch.
-                if (options?.allowNotStarted && !run && !eventFlushFailure)
-                    return false;
-                throw new Error(`Cannot confirm durable abort for missing run ${runId}`);
-            }
-            if (!abortPersisted && persistedStatus === "running") {
-                throw new Error(`Durable abort did not transition run ${runId}`);
+    const persistence = (async () => {
+        let eventFlushFailure;
+        try {
+            eventFlushFailure = await flushRunEventsBeforeAbort(run);
+        }
+        catch (error) {
+            if (run)
+                run.abortPersistenceManaged = false;
+            throw error;
+        }
+        let abortPersistedDurably = false;
+        try {
+            const abortPersisted = await markRunAborted(runId, reason);
+            abortPersistedDurably = abortPersisted;
+            if (!abortPersisted || eventFlushFailure) {
+                const persistedStatus = await getRunStatus(runId);
+                abortPersistedDurably ||= persistedStatus === "aborted";
+                if (persistedStatus === null) {
+                    // Agent Teams persists Stop intent before run registration.
+                    // Workers recheck it before dispatch.
+                    if (options?.allowNotStarted && !run && !eventFlushFailure)
+                        return false;
+                    throw new Error(`Cannot confirm durable abort for missing run ${runId}`);
+                }
+                if (!abortPersisted && persistedStatus === "running") {
+                    throw new Error(`Durable abort did not transition run ${runId}`);
+                }
             }
+            if (run)
+                run.abortPersistenceManaged = abortPersistedDurably;
+            if (eventFlushFailure)
+                throw eventFlushFailure;
         }
-        if (eventFlushFailure)
-            throw eventFlushFailure;
-    }
-    catch (error) {
-        captureError(error, {
-            route: "/_agent-native/agent-chat/runs/:id/abort",
-            aiTraceId: runId,
-            tags: {
-                source: "agent-run-manager",
-                phase: "abort-run",
-            },
-            extra: {
-                runId,
-                threadId: activeRuns.get(runId)?.threadId,
-                reason,
-                abortedInMemory,
-            },
-        });
-        console.error("[run-manager] durable abort persistence failed:", error instanceof Error ? error.message : error);
-        throw error;
+        catch (error) {
+            if (run)
+                run.abortPersistenceManaged = abortPersistedDurably;
+            captureError(error, {
+                route: "/_agent-native/agent-chat/runs/:id/abort",
+                aiTraceId: runId,
+                tags: {
+                    source: "agent-run-manager",
+                    phase: "abort-run",
+                },
+                extra: {
+                    runId,
+                    threadId: activeRuns.get(runId)?.threadId,
+                    reason,
+                    abortedInMemory,
+                },
+            });
+            console.error("[run-manager] durable abort persistence failed:", error instanceof Error ? error.message : error);
+            throw error;
+        }
+        return abortedInMemory;
+    })();
+    if (run) {
+        run.abortPersistencePromise = persistence.then(() => run.abortPersistenceManaged ?? false, () => run.abortPersistenceManaged ?? false);
     }
-    return abortedInMemory;
+    return persistence;
 }
 async function abortRunAtSafeBoundaryDurablyResult(runId, reason = "user") {
     const run = activeRuns.get(runId);