@agent-native/core 0.219.0 → 0.220.0-nightly-20261023212848

package/dist/agent/production-agent.js

@@ -9,7 +9,7 @@ import { parseA2AAgentActivityPart } from "../a2a/activity.js";
 import { actionCallIsRetrySafe, actionChangeResource, classifyActionCall, } from "../action-call-classification.js";
 import { runOutsideActionInvocation, vouchedOutcome } from "../action-frame.js";
 import { ACTION_CHAT_UI_RECORD_CHANGE_RENDERER, normalizeActionChangeResult, } from "../action-ui.js";
-import { AgentConnectionRequiredError, describeToolParameterSignature, isActionContractError, isActionHiddenFromEveryAgentSurface, isAgentActionStopError, isAgentConnectionRequiredError, actionCallIntent, invocationEffect, runPreparedActionCall, boundActionCallIntent, preparedCallArguments, preparedCallNeedsApproval, recordInvalidActionCall, stripUnsupportedSchemaKeywords, } from "../action.js";
+import { AgentConnectionRequiredError, describeToolParameterSignature, isActionContractError, isActionHiddenFromEveryAgentSurface, isAgentActionStopError, isAgentConnectionRequiredError, actionCallIntent, ActionInputValidationError, invocationEffect, runPreparedActionCall, boundActionCallIntent, preparedCallArguments, preparedCallNeedsApproval, recordInvalidActionCall, stripUnsupportedSchemaKeywords, } from "../action.js";
 import { getAppConfig } from "../app-config/index.js";
 import { MAX_BACKGROUND_RUN_CONTINUATIONS, MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS, MAX_TURN_WALL_CLOCK_MS, } from "../app-config/run-lifecycle-invariants.js";
 import { readAppState } from "../application-state/script-helpers.js";
@@ -90,6 +90,7 @@ import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js
 import { applyUncheckedDefaultModelReplacement } from "./provider-model-selection.js";
 import { startRun, subscribeToRun, replayCompletedTurn, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, getSlotHoldingRunId, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, endsAfterToolResultWithoutAssistantFinal, endsDuringActionPreparation, } from "./run-manager.js";
 import { writeLedgerEntry, readLedgerEntry, beginAgentExecutionStep, completeAgentExecutionStep, markAgentExecutionStepDispatched, markAgentExecutionStepUnknown, recordLateAgentExecutionStepOutcome, clearLedgerForThread, AgentTurnInitiatorMismatchError, AgentTurnInitiatorUnavailableError, insertRun, insertRunEvent, isRunAborted, isTurnAborted, markRunAborted, updateRunHeartbeat, updateRunStatusIfRunning, updateRunTerminalStateIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn, RUN_DIAG_STAGE, UNCLAIMED_BACKGROUND_RUN_GRACE_MS, turnRunLedgerExhausted, } from "./run-store.js";
+import { setRunTurnIdHeader } from "./run-turn-id-header.js";
 import { buildCurrentTimeUserContext } from "./runtime-context.js";
 import { claimSetupResume, setupResumeRefusedRunId, } from "./setup-resume-claim.js";
 import { getStrictToolInputValidator } from "./strict-tool-input.js";
@@ -3130,6 +3131,7 @@ function* historyToolResults(turnMessages, actions, readOnlyCalls, priorCallIden
                         : {}),
                     readOnly: readOnlyCalls.has(callPart),
                     dedupe: actions[callPart.name]?.dedupe !== false,
+                    input: callPart.input,
                 },
             };
         }
@@ -3323,23 +3325,42 @@ const LOOP_BREAKER_STOP_CODES = new Set([
 function isLoopBreakerStop(stop) {
     return LOOP_BREAKER_STOP_CODES.has(stop.errorCode ?? "");
 }
-function noteUnknownOutcome(outcomes, tool, argumentsHash) {
+function noteUnknownOutcome(outcomes, tool, argumentsHash, cause = "interruption", input) {
     outcomes.tools.set(tool, (outcomes.tools.get(tool) ?? 0) + 1);
-    if (!argumentsHash)
+    outcomes.causes.set(tool, cause);
+    if (input !== undefined) {
+        const inputKey = toolCallCacheKey(tool, input);
+        outcomes.inputs.set(inputKey, (outcomes.inputs.get(inputKey) ?? 0) + 1);
+    }
+    if (!argumentsHash) {
+        outcomes.unidentified.set(tool, (outcomes.unidentified.get(tool) ?? 0) + 1);
         return;
+    }
     const key = preparedToolCallKey(tool, argumentsHash);
     outcomes.calls.set(key, (outcomes.calls.get(key) ?? 0) + 1);
 }
+/** Why a write of a tool with an unknown earlier call did not run. */
+function unknownSiblingResult(tool) {
+    return `Not run: an earlier ${tool} call in this turn may have already applied, and its result is unknown. Running ${tool} again could apply the change twice. Check the current state with a read, then tell the user what you found instead of calling ${tool} again in this turn.`;
+}
 function noUnknownOutcomes() {
-    return { tools: new Map(), calls: new Map() };
+    return {
+        tools: new Map(),
+        calls: new Map(),
+        inputs: new Map(),
+        unidentified: new Map(),
+        causes: new Map(),
+    };
 }
 /** Each count in `from` that is larger than the one in `into`. */
 function mergeUnknownOutcomes(into, from) {
-    for (const kind of ["tools", "calls"]) {
+    for (const kind of ["tools", "calls", "inputs", "unidentified"]) {
         for (const [key, count] of from[kind]) {
             into[kind].set(key, Math.max(into[kind].get(key) ?? 0, count));
         }
     }
+    for (const [tool, cause] of from.causes)
+        into.causes.set(tool, cause);
 }
 /**
  * Adds to `outcomes` those a continued turn starts with, from its journal's
@@ -3350,7 +3371,7 @@ function mergeUnknownOutcomes(into, from) {
 function seedUnknownOutcomes(outcomes, messages, actions, readOnlyCalls, priorCallEffects, priorCallIdentities, interrupted) {
     const fromJournal = noUnknownOutcomes();
     for (const entry of interrupted) {
-        noteUnknownOutcome(fromJournal, entry.tool, entry.argumentsHash);
+        noteUnknownOutcome(fromJournal, entry.tool, entry.argumentsHash, "interruption", entry.input);
     }
     mergeUnknownOutcomes(outcomes, fromJournal);
     if (!isInternalContinuationTurn(messages))
@@ -3379,7 +3400,7 @@ function seedUnknownOutcomes(outcomes, messages, actions, readOnlyCalls, priorCa
                     (part.isError === true &&
                         typeof part.content === "string" &&
                         isToolCallTimeoutResult(part.content)))) {
-            noteUnknownOutcome(fromHistory, call.name, effect ? priorCallIdentities.get(call.identityKey ?? "") : undefined);
+            noteUnknownOutcome(fromHistory, call.name, effect ? priorCallIdentities.get(call.identityKey ?? "") : undefined, "interruption", call.input);
         }
     }
     const callsByProviderId = new Map();
@@ -3420,7 +3441,7 @@ function seedUnknownOutcomes(outcomes, messages, actions, readOnlyCalls, priorCa
         }
     }
     for (const call of ambiguousUnknownCalls) {
-        noteUnknownOutcome(fromHistory, call.name, undefined);
+        noteUnknownOutcome(fromHistory, call.name, undefined, "interruption", call.input);
     }
     mergeUnknownOutcomes(outcomes, fromHistory);
 }
@@ -4448,6 +4469,20 @@ async function prepareToolCall(entry, input, signal, timeoutMs) {
 function intentIsReadOnly(intent) {
     return intent?.valid === true && intent.readOnly === true;
 }
+function isBoundedTaskWait(toolName, input) {
+    if (toolName !== "agent-teams" || !input || typeof input !== "object") {
+        return false;
+    }
+    const args = input;
+    // Only these operations honor the task reader's bounded wait contract.
+    return ((args.action === "status" || args.action === "read-result") &&
+        typeof args.taskId === "string" &&
+        args.taskId.trim().length > 0 &&
+        typeof args.waitMs === "number" &&
+        Number.isInteger(args.waitMs) &&
+        args.waitMs > 0 &&
+        args.waitMs <= 20_000);
+}
 function normalizeOptionalToolPlaceholders(schema, input) {
     if (!schema?.properties || !input || typeof input !== "object") {
         return { input, changed: false };
@@ -4968,21 +5003,28 @@ export async function runAgentLoop(opts) {
     const readOnlyToolResultCache = seedReadOnlyToolResultsFromHistory(messages, actions, historyReadOnlyCalls, priorCallEffects, priorCallIdentities);
     const duplicateReadOnlyToolCalls = seedDuplicateReadOnlyToolCallsFromHistory(messages, actions, historyReadOnlyCalls, priorCallEffects, priorCallIdentities);
     const unknownOutcomes = opts.unknownOutcomes ?? noUnknownOutcomes();
-    seedUnknownOutcomes(unknownOutcomes, messages, actions, historyReadOnlyCalls, priorCallEffects, priorCallIdentities, internalContinuationTurn ? (toolCallJournal?.interrupted ?? []) : []);
+    // A recovered retry (a team attempt after a crash, an A2A redelivery)
+    // re-plans from the task text, so a repeated write gets a new step id and
+    // only these journal entries show it may already have run. Approval
+    // continuations stay out: their paused call is interrupted by design.
+    seedUnknownOutcomes(unknownOutcomes, messages, actions, historyReadOnlyCalls, priorCallEffects, priorCallIdentities, internalContinuationTurn || opts.recoverCompletedExecutionSteps === true
+        ? (toolCallJournal?.interrupted ?? [])
+        : []);
     if (internalContinuationTurn) {
         for (const entry of toolCallJournal?.completed ?? []) {
             if (!journalEntriesAmbiguous.has(entry.key))
                 continue;
-            unknownOutcomes.tools.set(entry.tool, Math.max(unknownOutcomes.tools.get(entry.tool) ?? 0, 1));
-            if (entry.argumentsHash) {
-                const key = preparedToolCallKey(entry.tool, entry.argumentsHash);
-                unknownOutcomes.calls.set(key, Math.max(unknownOutcomes.calls.get(key) ?? 0, 1));
-            }
+            const seeded = noUnknownOutcomes();
+            noteUnknownOutcome(seeded, entry.tool, entry.argumentsHash, "interruption", entry.input);
+            mergeUnknownOutcomes(unknownOutcomes, seeded);
         }
     }
-    // Names a caller shares between its own loops hold back writes, as before.
+    // Names a caller shares between its own loops carry no identity, so they
+    // hold back every write of the tool.
     for (const tool of opts.unknownWriteToolNames ?? []) {
-        unknownOutcomes.tools.set(tool, Math.max(unknownOutcomes.tools.get(tool) ?? 0, 1));
+        const seeded = noUnknownOutcomes();
+        noteUnknownOutcome(seeded, tool, undefined);
+        mergeUnknownOutcomes(unknownOutcomes, seeded);
     }
     const { sameArguments: repeatedToolErrors, sameTool: repeatedToolErrorsAnyArgs, } = seedRepeatedToolErrorCountsFromJournal(journalRead.status === "read" ? journalRead.priorToolCallSequence : [], toolCallCacheKey, normalizeToolErrorForBreaker);
     const repeatedToolCalls = seedRepeatedToolCallCountsFromJournal(journalRead.status === "read" ? journalRead.priorToolCallSequence : [], toolCallCacheKey, (name, result) => result.startsWith(resurfacedDuplicateReadOnlyToolResultPrefix(name)));
@@ -5038,6 +5080,8 @@ export async function runAgentLoop(opts) {
             error: stop.message,
             errorCode: stop.errorCode ?? "tool_failed",
             ...(stop.details ? { details: stop.details } : {}),
+            ...(stop.blockedTool ? { blockedTool: stop.blockedTool } : {}),
+            ...(stop.blockedBy ? { blockedBy: stop.blockedBy } : {}),
             recoverable: false,
         });
     };
@@ -5977,7 +6021,12 @@ export async function runAgentLoop(opts) {
             const actionRetrySafe = actionEntry && intent?.valid
                 ? actionCallIsRetrySafe(actionEntry, preparedCallArguments(intent))
                 : false;
-            const repeatGuardStopFromThisCall = noteRepeatedToolCall(toolCall.name, toolCall.input, toolCall.id);
+            const repeatGuardStopFromThisCall = actionIsReadOnly &&
+                actionEntry?.dedupe === false &&
+                intent?.valid === true &&
+                isBoundedTaskWait(toolCall.name, preparedCallArguments(intent))
+                ? null
+                : noteRepeatedToolCall(toolCall.name, toolCall.input, toolCall.id);
             const rollbackRepeatedToolCall = () => {
                 const repeatKey = toolCallCacheKey(toolCall.name, toolCall.input);
                 const repeatCall = inFlightRepeatToolCalls.get(toolCall.id);
@@ -6010,6 +6059,7 @@ export async function runAgentLoop(opts) {
             let actionInvoked = false;
             // Live once invoked, so an abandoned call still reads what ran in it.
             const actionExecutionOutcome = { refused: false };
+            let unknownOutcomeCause = "interruption";
             const ranEffect = (settled) => actionInvoked && actionEntry
                 ? invocationEffect(actionEntry, actionExecutionOutcome, {
                     readOnly: actionIsReadOnly,
@@ -6025,7 +6075,7 @@ export async function runAgentLoop(opts) {
                 // holds back its action's writes as a write's would.
                 if (event.outcomeUnknown) {
                     opts.unknownWriteToolNames?.add(toolCall.name);
-                    noteUnknownOutcome(unknownOutcomes, toolCall.name, argumentsHash);
+                    noteUnknownOutcome(unknownOutcomes, toolCall.name, argumentsHash, unknownOutcomeCause, toolCall.input);
                 }
                 // A write that errored after it was invoked may still have committed,
                 // retry-safe or not, so cached reads of its target are stale.
@@ -6188,7 +6238,7 @@ export async function runAgentLoop(opts) {
                     : "";
                 return `Error running ${toolCall.name}: ${message}${errorCode}${rateLimitRecoveryHint(message, err)}`;
             };
-            const declineToolCall = (guidance, isError = false) => {
+            const declineToolCall = (guidance, isError = false, errorClass) => {
                 const result = finalizeToolErrorResult(guidance);
                 return (async () => {
                     await send({
@@ -6205,6 +6255,7 @@ export async function runAgentLoop(opts) {
                         result,
                         isError: true,
                         completedSideEffect: false,
+                        ...(errorClass ? { errorClass } : {}),
                     });
                     recordToolResult(result, true);
                     return {
@@ -6296,11 +6347,11 @@ export async function runAgentLoop(opts) {
             }
             const toolCallSchemaError = toolCallSchemaErrorsByCall.get(toolCall);
             if (toolCallSchemaError && !repairedInput.changed) {
-                return declineToolCall(toolInputSchemaErrorResult(toolCall.name, toolCallSchemaError.input, toolCallSchemaError.error, actionEntry.tool.parameters, toolCallTruncatedByOutputCap), true);
+                return declineToolCall(toolInputSchemaErrorResult(toolCall.name, toolCallSchemaError.input, toolCallSchemaError.error, actionEntry.tool.parameters, toolCallTruncatedByOutputCap), true, "input_invalid");
             }
             const rawToolInputError = validateRawToolInput(actionEntry, toolCall.input);
             if (rawToolInputError) {
-                return declineToolCall(toolInputSchemaErrorResult(toolCall.name, toolCall.input, rawToolInputError, actionEntry.tool.parameters, toolCallTruncatedByOutputCap), true);
+                return declineToolCall(toolInputSchemaErrorResult(toolCall.name, toolCall.input, rawToolInputError, actionEntry.tool.parameters, toolCallTruncatedByOutputCap), true, "input_invalid");
             }
             if (!intent?.valid) {
                 await recordInvalidActionCall(actionEntry, toolCall.input, {
@@ -6309,7 +6360,7 @@ export async function runAgentLoop(opts) {
                     userEmail: userEmail ?? undefined,
                     orgId: opts.orgId ?? getRequestOrgId() ?? null,
                 }, intent?.error);
-                return declineToolCall(thrownToolResult(intent?.error), true);
+                return declineToolCall(thrownToolResult(intent?.error), true, "input_invalid");
             }
             const approvalKey = toolCallCacheKey(toolCall.name, toolCall.input);
             // The exact arguments the call runs with, defaults applied, bind its
@@ -6601,6 +6652,8 @@ export async function runAgentLoop(opts) {
                 requestedActionStop ??= {
                     message: result,
                     errorCode: "write_tool_outcome_unknown",
+                    blockedTool: toolCall.name,
+                    blockedBy: "interruption",
                 };
                 return {
                     type: "tool-result",
@@ -6670,11 +6723,13 @@ export async function runAgentLoop(opts) {
                     };
                 }
             }
-            // An unknown write cannot become fresh work merely by rewording its
-            // arguments, or by eliding its tool pair from the replayed history.
+            // Running an unknown call again exactly as it was prepared could apply
+            // it twice. A write with no identity to compare cannot be told from a
+            // repeat, whatever its arguments, nor can one whose tool pair was
+            // elided from the replayed history.
             const priorInterruptionsBeforeStepReplay = actionIsReadOnly
                 ? (unknownOutcomes.calls.get(preparedCallKey) ?? 0)
-                : (unknownOutcomes.tools.get(toolCall.name) ?? 0);
+                : Math.max(unknownOutcomes.calls.get(preparedCallKey) ?? 0, unknownOutcomes.inputs.get(toolCallCacheKey(toolCall.name, toolCall.input)) ?? 0, unknownOutcomes.unidentified.get(toolCall.name) ?? 0);
             const priorInterruptions = ambiguousLegacyWrite
                 ? Math.max(1, priorInterruptionsBeforeStepReplay)
                 : (interruptedCallMatchesStep ||
@@ -6683,10 +6738,20 @@ export async function runAgentLoop(opts) {
                     priorInterruptionsBeforeStepReplay > 0
                     ? 0
                     : priorInterruptionsBeforeStepReplay;
+            // Another write of a tool whose earlier call may have applied could
+            // apply the same change twice, so it does not run; the turn goes on,
+            // and only an exact repeat stops it.
+            if (!actionIsReadOnly &&
+                !actionRetrySafe &&
+                priorInterruptionsBeforeStepReplay === 0 &&
+                (unknownOutcomes.tools.get(toolCall.name) ?? 0) > 0) {
+                return declineToolCall(unknownSiblingResult(toolCall.name), true);
+            }
             if (priorInterruptions > 0) {
-                // Only a result recorded for these exact arguments is recovered. Any
-                // other leaves the earlier attempt unknown, so the call stops below
-                // instead of running again.
+                // Only a result recorded for these exact arguments is recovered, so
+                // a result found is the interrupted call's own. Any other leaves the
+                // earlier attempt unknown, so the call stops below instead of
+                // running again.
                 const ledgerResult = !ambiguousLegacyWrite && opts.threadId && !executionStepIntent
                     ? await waitForInterruptedToolLedgerEntry({
                         threadId: opts.threadId,
@@ -6763,6 +6828,8 @@ export async function runAgentLoop(opts) {
                     message: `I stopped before running ${toolCall.name} again. ${priorInterruptions === 1 ? "An earlier attempt" : `${priorInterruptions} earlier attempts`} may have already saved changes and I could not confirm the result. ` +
                         `Check what was saved, then reply "continue" and I will verify it before doing anything else.`,
                     errorCode: "write_tool_outcome_unknown",
+                    blockedTool: toolCall.name,
+                    blockedBy: unknownOutcomes.causes.get(toolCall.name) ?? "interruption",
                 };
                 return {
                     type: "tool-result",
@@ -6882,6 +6949,8 @@ export async function runAgentLoop(opts) {
                 // commit, so a retry-safe action stays blocked for it; an error the
                 // handler returned does not.
                 let toolResultLost = false;
+                // It returned an error result rather than throwing one.
+                let toolReportedError = false;
                 let toolErrorCode;
                 let toolErrorDetailsLine = "";
                 let mcpApp;
@@ -7070,6 +7139,7 @@ export async function runAgentLoop(opts) {
                         typeof mcpResult.raw === "object" &&
                         mcpResult.raw.isError === true) {
                         isError = true;
+                        toolReportedError = true;
                     }
                     mcpApp = mcpResult?.mcpApp;
                     let resultForAgent = rawForAgent;
@@ -7189,6 +7259,7 @@ export async function runAgentLoop(opts) {
                         throw err;
                     }
                     thrown = err;
+                    toolReportedError = false;
                     toolResultLost =
                         signal.aborted ||
                             isToolCallTimeoutResult(String(err?.message ?? err));
@@ -7203,8 +7274,21 @@ export async function runAgentLoop(opts) {
                 }
                 const call = actionExecutionOutcome.record;
                 const { effect: callEffect, changed: callChanged } = ranEffect(isError
-                    ? { failed: { error: thrown, lost: toolResultLost } }
+                    ? {
+                        failed: {
+                            error: thrown,
+                            lost: toolResultLost,
+                            reported: toolReportedError,
+                        },
+                    }
                     : { receipt });
+                const toolErrorClass = !isError
+                    ? undefined
+                    : thrown instanceof ActionInputValidationError
+                        ? "input_invalid"
+                        : callEffect === "none" && !actionIsReadOnly
+                            ? "rejected"
+                            : undefined;
                 if (isError) {
                     receipt = undefined;
                     if (result !== INTERRUPTED_TOOL_RESULT_MARKER) {
@@ -7285,6 +7369,7 @@ export async function runAgentLoop(opts) {
                     executionStepOutcomeRecorded = true;
                 }
                 toolDonePersistenceFailed = true;
+                unknownOutcomeCause = toolResultLost ? "interruption" : "rejection";
                 await emitToolDone({
                     type: "tool_done",
                     id: toolCall.id,
@@ -7293,6 +7378,7 @@ export async function runAgentLoop(opts) {
                     result,
                     ...(isError ? { isError: true } : {}),
                     ...(toolErrorCode ? { errorCode: toolErrorCode } : {}),
+                    ...(toolErrorClass ? { errorClass: toolErrorClass } : {}),
                     ...(callEffect === "unknown"
                         ? { outcomeUnknown: true }
                         : isError || receipt || callEffect === "committed"
@@ -9398,6 +9484,7 @@ export function createProductionAgentHandler(options) {
                 setResponseHeader(event, "Cache-Control", "no-cache");
                 setResponseHeader(event, "Connection", "keep-alive");
                 setResponseHeader(event, "X-Run-Id", result.submittedRunId);
+                setRunTurnIdHeader(event, getRun(result.submittedRunId)?.turnId);
                 setResponseHeader(event, "X-Dispatch-Mode", "replay");
                 return stream;
             }
@@ -9486,6 +9573,7 @@ export function createProductionAgentHandler(options) {
                     setResponseHeader(event, "Cache-Control", "no-cache");
                     setResponseHeader(event, "Connection", "keep-alive");
                     setResponseHeader(event, "X-Run-Id", submittedRunId);
+                    setRunTurnIdHeader(event, getRun(submittedRunId)?.turnId);
                     setResponseHeader(event, "X-Dispatch-Mode", "replay");
                     return stream;
                 }
@@ -10780,6 +10868,11 @@ export function createProductionAgentHandler(options) {
                     !queuedMessageId &&
                     !queuedMessageClaimId &&
                     !isBackgroundWorker);
+                const queuedSubmissionStore = shouldPreserveQueuedOrder
+                    ? await import("../chat-threads/store.js")
+                    : undefined;
+                // The inbox read runs under the slot lock, but its schema must be ready first.
+                await queuedSubmissionStore?.ensureChatThreadTables();
                 slot = await tryClaimRunSlot(threadId, runId, undefined, {
                     turnId: effectiveTurnId,
                     ...(turnInitiator ? { turnInitiator } : {}),
@@ -10795,12 +10888,9 @@ export function createProductionAgentHandler(options) {
                         ? { dispatchPayload: durableDispatchPayload }
                         : {}),
                     ...(continueOf ? { continueOf } : {}),
-                    ...(shouldPreserveQueuedOrder
+                    ...(queuedSubmissionStore
                         ? {
-                            hasPendingQueuedSubmission: async (tx) => {
-                                const { hasPendingQueuedSubmissionReceipt } = await import("../chat-threads/store.js");
-                                return hasPendingQueuedSubmissionReceipt(tx, runThreadId);
-                            },
+                            hasPendingQueuedSubmission: (tx) => queuedSubmissionStore.hasPendingQueuedSubmissionReceipt(tx, runThreadId),
                         }
                         : {}),
                 });
@@ -10833,6 +10923,9 @@ export function createProductionAgentHandler(options) {
                 setResponseHeader(event, "Cache-Control", "no-cache");
                 setResponseHeader(event, "Connection", "keep-alive");
                 setResponseHeader(event, "X-Run-Id", slot.completedRunId);
+                // The client leaves a replay's turn out unless named here, and this
+                // replay was found by its turn, so the stored turn is known.
+                setRunTurnIdHeader(event, effectiveTurnId);
                 setResponseHeader(event, "X-Dispatch-Mode", "replay");
                 return stream;
             }
@@ -11074,6 +11167,7 @@ export function createProductionAgentHandler(options) {
                     setResponseHeader(event, "Cache-Control", "no-cache");
                     setResponseHeader(event, "Connection", "keep-alive");
                     setResponseHeader(event, "X-Run-Id", duplicateRunId);
+                    setRunTurnIdHeader(event, getRun(duplicateRunId)?.turnId);
                     setResponseHeader(event, "X-Dispatch-Mode", "replay");
                     return stream;
                 }
@@ -11174,6 +11268,7 @@ export function createProductionAgentHandler(options) {
                     setResponseHeader(event, "Cache-Control", "no-cache");
                     setResponseHeader(event, "Connection", "keep-alive");
                     setResponseHeader(event, "X-Run-Id", runId);
+                    setRunTurnIdHeader(event, effectiveTurnId);
                     setResponseHeader(event, "X-Dispatch-Mode", "background");
                     return stream;
                 }
@@ -11503,7 +11598,7 @@ export function createProductionAgentHandler(options) {
                 void retainRequestDbPoolScope(recordRunDiagnostic(runId, RUN_DIAG_STAGE.setupTimings, setupDetail).catch(() => { })).catch(() => { });
             }
             if (options.onRunStart) {
-                await options.onRunStart(send, threadId ?? runId, runId);
+                await options.onRunStart(send, threadId ?? runId, runId, effectiveTurnId);
             }
             const unknownOutcomes = noUnknownOutcomes();
             if (customAgentRefs.length > 0) {
@@ -11938,6 +12033,7 @@ export function createProductionAgentHandler(options) {
                             loopOpts: agentLoopOpts,
                             runId,
                             threadId: threadId ?? null,
+                            turnId: effectiveTurnId,
                             userId: ownerEmail,
                             config: obsConfig,
                             spanName: turnUsageLabel && turnUsageLabel !== "chat"
@@ -12047,10 +12143,12 @@ export function createProductionAgentHandler(options) {
                     : "foreground",
             runRowAlreadyInserted: foregroundRunRowInserted,
             executionLease: true,
+            // An anonymous run is not a user; `run_started` does not name one either.
+            userId: turnInitiator?.anonymous
+                ? undefined
+                : (ownerEmail ?? undefined),
             // Resolved AFTER stored-model/experiment overrides — the same value
             // actually sent to the engine, not the raw client-requested model.
-            // No userId here: `ownerEmail` is the only identity known at this
-            // scope and is PII (email), which the terminal event must not carry.
             model: effectiveModel,
             engineName: engine.name,
             attemptCount: backgroundContinuationCount,
@@ -12068,6 +12166,7 @@ export function createProductionAgentHandler(options) {
         setResponseHeader(event, "Cache-Control", "no-cache");
         setResponseHeader(event, "Connection", "keep-alive");
         setResponseHeader(event, "X-Run-Id", runId);
+        setRunTurnIdHeader(event, effectiveTurnId);
         setResponseHeader(event, "X-Dispatch-Mode", foregroundSelfChainEligible ? "foreground-self-chain" : "foreground");
         return stream;
     });