@agent-native/core 0.220.0-nightly-20261024033422 → 0.220.0

package/dist/a2a/handlers.js

@@ -264,7 +264,7 @@ export async function processA2ATaskFromQueue(taskId, config, event) {
             }, A2A_PROCESSING_HEARTBEAT_MS);
             heartbeat.unref?.();
             try {
-                await processClaimedA2ATask(taskId, claimed, config, workerAbort.signal, event);
+                await processClaimedA2ATask(taskId, claimed, config, workerAbort.signal, event, fence.generation);
             }
             finally {
                 clearInterval(heartbeat);
@@ -285,7 +285,7 @@ export async function processA2ATaskFromQueue(taskId, config, event) {
         }
     }
 }
-async function processClaimedA2ATask(taskId, claimed, config, signal, event) {
+async function processClaimedA2ATask(taskId, claimed, config, signal, event, processingAttemptId) {
     const message = claimed.history?.[0];
     if (!message) {
         await settleProcessingA2ATask(taskId, {
@@ -378,7 +378,7 @@ async function processClaimedA2ATask(taskId, claimed, config, signal, event) {
                     ? { orgScope: "personal" }
                     : {}),
             ...(requestOrigin ? { requestOrigin } : {}),
-        }, () => runHandlerAndPersist(taskId, message, config, contextId, callerMetadata, event, sourceContext, verifiedEmail, signal));
+        }, () => runHandlerAndPersist(taskId, message, config, contextId, callerMetadata, event, sourceContext, verifiedEmail, signal, processingAttemptId));
     }
     catch (err) {
         try {
@@ -471,11 +471,12 @@ function jsonRpcError(id, code, message) {
 function jsonRpcResult(id, result) {
     return { jsonrpc: "2.0", id, result };
 }
-function makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal) {
+function makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal, processingAttemptId) {
     const artifacts = [];
     const pendingFileArtifacts = [];
     const context = {
         taskId,
+        processingAttemptId,
         contextId,
         metadata,
         event,
@@ -573,8 +574,8 @@ async function withA2ARequestContext(metadata, event, fn) {
         ...(requestOrigin ? { requestOrigin } : {}),
     }, fn);
 }
-async function runHandlerAndPersist(taskId, message, config, contextId, metadata, event, sourceContext, ownerEmail, signal) {
-    const { context, artifacts, persistFileArtifacts } = makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal);
+async function runHandlerAndPersist(taskId, message, config, contextId, metadata, event, sourceContext, ownerEmail, signal, processingAttemptId) {
+    const { context, artifacts, persistFileArtifacts } = makeHandlerContext(taskId, contextId, metadata, event, sourceContext, ownerEmail, signal, processingAttemptId);
     try {
         signal?.throwIfAborted();
         const result = getHandler(config)(message, context);

package/dist/a2a/types.d.ts

@@ -149,6 +149,7 @@ export interface A2ACorrelationMetadata {
 }
 export interface A2AHandlerContext {
     taskId: string;
+    processingAttemptId?: string;
     contextId?: string;
     metadata?: Record<string, unknown>;
     event?: unknown;

package/dist/agent/engine/tool-call-journal-seed.js

@@ -1,5 +1,5 @@
 import { isArtifactReceipt, } from "../../artifacts/detect.js";
-import { getCompletedAgentExecutionSteps, getCurrentTurnEventsForThread, } from "../run-store.js";
+import { AgentRunJournalUnreadableError, getCompletedAgentExecutionSteps, getCurrentTurnEventsForThread, } from "../run-store.js";
 import { classifyToolCallJournal, isConsistentToolCallInputFingerprint, toolCallInputFingerprint, } from "../tool-call-journal.js";
 const LEDGER_READ_RETRY_MS = 250;
 function isRecord(value) {
@@ -36,15 +36,15 @@ function durableStepFileMutation(value) {
     }
     return { path: value.path, contentSha256: value.contentSha256 };
 }
-function durableStepToolDone(event, row) {
+function durableStepToolDone(event, row, unreadable) {
     const executionStepId = event.executionStepId ?? event.id;
     if (!executionStepId ||
         executionStepId !== row.stepId ||
         row.operationId !== row.stepId) {
-        throw new Error(`Completed execution step ${row.stepId} does not match its ledger identity`);
+        return unreadable(`Completed execution step ${row.stepId} does not match its ledger identity`);
     }
     if (event.tool !== row.toolName) {
-        throw new Error(`Completed execution step ${row.stepId} does not match ledger tool ${event.tool}`);
+        return unreadable(`Completed execution step ${row.stepId} does not match ledger tool ${event.tool}`);
     }
     let input;
     let outcome;
@@ -53,7 +53,7 @@ function durableStepToolDone(event, row) {
         outcome = JSON.parse(row.resultJson);
     }
     catch (error) {
-        throw new Error(`Completed execution step ${row.stepId} has unreadable stored intent or result`, { cause: error });
+        return unreadable(`Completed execution step ${row.stepId} has unreadable stored intent or result`, error);
     }
     if (!isRecord(input) ||
         typeof input.argumentsHash !== "string" ||
@@ -63,11 +63,11 @@ function durableStepToolDone(event, row) {
         typeof outcome.result !== "string" ||
         typeof outcome.isError !== "boolean" ||
         typeof outcome.completedSideEffect !== "boolean") {
-        throw new Error(`Completed execution step ${row.stepId} is missing replay identity or outcome fields`);
+        return unreadable(`Completed execution step ${row.stepId} is missing replay identity or outcome fields`);
     }
     if (outcome.errorCode !== undefined &&
         typeof outcome.errorCode !== "string") {
-        throw new Error(`Completed execution step ${row.stepId} has an invalid error code`);
+        return unreadable(`Completed execution step ${row.stepId} has an invalid error code`);
     }
     const artifacts = Array.isArray(outcome.artifacts)
         ? outcome.artifacts.filter(isArtifactReceipt)
@@ -129,56 +129,60 @@ export async function overlayCompletedExecutionStepOutcomes(threadId, turnId, ev
     const replacedIndexes = new Set();
     const replacementsAt = new Map();
     const replacementsAfter = new Map();
-    for (const row of rows) {
+    for (const [rowIndex, row] of rows.entries()) {
+        const unreadable = (message, cause) => {
+            const detail = new Error(message, cause === undefined ? undefined : { cause });
+            throw new AgentRunJournalUnreadableError(threadId, turnId, rowIndex, "invalid_execution_step", { cause: detail });
+        };
         if (!candidateIds.includes(row.stepId)) {
-            throw new Error(`Completed execution step ${row.stepId} was not requested by the ledger`);
+            return unreadable(`Completed execution step ${row.stepId} was not requested by the ledger`);
         }
         if (rowsById.has(row.stepId)) {
-            throw new Error(`Completed execution step ${row.stepId} has ambiguous stored rows`);
+            return unreadable(`Completed execution step ${row.stepId} has ambiguous stored rows`);
         }
         const starts = startsById.get(row.stepId);
         if (!starts || starts.length === 0) {
-            throw new Error(`Completed execution step ${row.stepId} has no matching ledger call`);
+            return unreadable(`Completed execution step ${row.stepId} has no matching ledger call`);
         }
         const canonicalStart = starts[0].event;
-        const canonicalDone = durableStepToolDone(canonicalStart, row);
+        const canonicalDone = durableStepToolDone(canonicalStart, row, unreadable);
         if (!isConsistentToolCallInputFingerprint(canonicalStart.input, canonicalStart.inputFingerprint, canonicalStart.inputStoredFingerprint)) {
-            throw new Error(`Completed execution step ${row.stepId} has unreadable ledger call identity`);
+            return unreadable(`Completed execution step ${row.stepId} has unreadable ledger call identity`);
         }
         const canonicalFingerprint = getToolCallEventFingerprint(canonicalStart);
         for (const { event } of starts.slice(1)) {
             if (event.tool !== canonicalStart.tool ||
                 !isConsistentToolCallInputFingerprint(event.input, event.inputFingerprint, event.inputStoredFingerprint) ||
                 getToolCallEventFingerprint(event) !== canonicalFingerprint) {
-                throw new Error(`Completed execution step ${row.stepId} has conflicting ledger call identities`);
+                return unreadable(`Completed execution step ${row.stepId} has conflicting ledger call identities`);
             }
         }
         const dones = donesById.get(row.stepId) ?? [];
         for (const { event } of dones) {
             if (event.tool !== row.toolName ||
                 !isConsistentToolCallInputFingerprint(event.input, event.inputFingerprint, event.inputStoredFingerprint)) {
-                throw new Error(`Completed execution step ${row.stepId} conflicts with its tool_done identity`);
+                return unreadable(`Completed execution step ${row.stepId} conflicts with its tool_done identity`);
             }
             const doneFingerprint = getToolCallEventFingerprint(event);
             if (canonicalFingerprint !== undefined &&
                 doneFingerprint !== undefined &&
                 doneFingerprint !== canonicalFingerprint) {
-                throw new Error(`Completed execution step ${row.stepId} conflicts with its tool_done input`);
+                return unreadable(`Completed execution step ${row.stepId} conflicts with its tool_done input`);
             }
             if (event.argumentsHash !== undefined &&
                 event.argumentsHash !== canonicalDone.argumentsHash) {
-                throw new Error(`Completed execution step ${row.stepId} conflicts with its tool_done arguments`);
+                return unreadable(`Completed execution step ${row.stepId} conflicts with its tool_done arguments`);
             }
             if (event.completedSideEffect !== undefined &&
                 event.completedSideEffect !== canonicalDone.completedSideEffect) {
-                throw new Error(`Completed execution step ${row.stepId} conflicts with its tool_done side-effect outcome`);
+                return unreadable(`Completed execution step ${row.stepId} conflicts with its tool_done side-effect outcome`);
             }
             if (event.isError === true && canonicalDone.isError !== true) {
-                throw new Error(`Completed execution step ${row.stepId} conflicts with its tool_done error outcome`);
+                return unreadable(`Completed execution step ${row.stepId} conflicts with its tool_done error outcome`);
             }
             if (event.errorCode !== undefined &&
                 event.errorCode !== canonicalDone.errorCode) {
-                throw new Error(`Completed execution step ${row.stepId} conflicts with its tool_done error code`);
+                return unreadable(`Completed execution step ${row.stepId} conflicts with its tool_done error code`);
             }
         }
         rowsById.set(row.stepId, row);

package/dist/agent/execution-fence.d.ts

@@ -24,7 +24,7 @@ export declare function currentExecutionFenceForScope(scope: {
 export declare function withExecutionLeaseRequested<T>(work: () => T): T;
 export declare function withExecutionFence<T>(fence: ExecutionFence, work: () => T): T;
 export declare function runWithoutExecutionFence<T>(work: () => T): T;
-export declare function lockAndAssertCurrentExecutionFences(tx: DbExec): Promise<void>;
+export declare function lockAndAssertCurrentExecutionFences(tx: DbExec, ignoredFence?: ExecutionFence): Promise<void>;
 export declare function withFencedExecutionWrite<T>(write: (tx: DbExec) => Promise<T>, scope?: {
     runId?: string;
     threadId?: string;

package/dist/agent/execution-fence.js

@@ -66,9 +66,16 @@ export function runWithoutExecutionFence(work) {
     // now-expired lease through AsyncLocalStorage.
     return executionFenceStorage.run({ fences: [], executionLeaseRequested: false }, work);
 }
-export async function lockAndAssertCurrentExecutionFences(tx) {
+export async function lockAndAssertCurrentExecutionFences(tx, ignoredFence) {
     const fences = executionFenceStorage.getStore()?.fences ?? [];
     for (const activeFence of fences) {
+        if (ignoredFence &&
+            activeFence.threadId === ignoredFence.threadId &&
+            activeFence.turnId === ignoredFence.turnId &&
+            activeFence.runId === ignoredFence.runId &&
+            activeFence.generation === ignoredFence.generation) {
+            continue;
+        }
         const { rows } = await tx.execute({
             sql: `SELECT generation
             FROM agent_execution_leases

package/dist/agent/production-agent.js

@@ -89,13 +89,13 @@ import { maybeCompactThread, buildObservationalContext, hasObservationalMemory,
 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 { writeLedgerEntry, readLedgerEntry, beginAgentExecutionStep, completeAgentExecutionStep, markAgentExecutionStepDispatched, resetAgentExecutionStepBeforeInvocation, 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";
 import { normalizeSubmissionDeadlineMetadata } from "./submission-deadline.js";
-import { consumeAgentToolApproval, createAgentToolApproval, isAgentToolAlwaysAllowed, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
+import { consumeAgentToolApproval, createAgentToolApproval, ensureAgentToolApprovalTable, hasPendingAgentToolApproval, isAgentToolAlwaysAllowed, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
 import { toolCallInputSignature } from "./tool-call-input-signature.js";
 import { ambiguousLegacyCallEffectKey, findAmbiguousLegacyJournalEntryForCall, findInterruptedJournalEntryForCall, findInterruptedLegacyJournalEntryForCall, findReplayableJournalEntry, isUnavailableToolCallInput, journalEntriesAmbiguousInHistory, journalEntriesRepresentedInHistory, journalCallEffects, journalCallIdentities, matchToolCallResultsInHistory, toolCallIdentityKey, toolCallInputFingerprint, unmatchedAmbiguousLegacyToolCallResultsInHistory, } from "./tool-call-journal.js";
 import { redactSensitiveFields, sanitizeToolErrorText, sanitizeToolErrorValue, } from "./tool-error-redaction.js";
@@ -6150,6 +6150,8 @@ export async function runAgentLoop(opts) {
             let toolDoneEmitted = false;
             let toolDonePersistenceFailed = false;
             let executionStepFinalizationAttempted = false;
+            let executionStepDispatched = false;
+            let executionStepDispatchWrite;
             let executionStepOutcomeRecorded = false;
             let actionInvoked = false;
             // Live once invoked, so an abandoned call still reads what ran in it.
@@ -7038,6 +7040,7 @@ export async function runAgentLoop(opts) {
                 if (cacheKey && cachedResult) {
                     if (executionStepIntent) {
                         await markAgentExecutionStepDispatched(executionStepIntent);
+                        executionStepDispatched = true;
                     }
                     const previousResult = cachedResult.content;
                     const visible = isCachedToolResultVisibleInContext(contextMessages, toolCall, previousResult);
@@ -7165,7 +7168,10 @@ export async function runAgentLoop(opts) {
                             throw new Error("Run aborted");
                         }
                         if (executionStepIntent) {
-                            await markAgentExecutionStepDispatched(executionStepIntent);
+                            executionStepDispatchWrite = markAgentExecutionStepDispatched(executionStepIntent).then(() => {
+                                executionStepDispatched = true;
+                            });
+                            await executionStepDispatchWrite;
                         }
                         if (timeoutSignal.aborted) {
                             throw new Error(timeoutMessage());
@@ -7432,7 +7438,7 @@ export async function runAgentLoop(opts) {
                     thrown = err;
                     toolReportedError = false;
                     toolResultLost =
-                        signal.aborted ||
+                        (signal.aborted && actionInvoked) ||
                             isToolCallTimeoutResult(String(err?.message ?? err));
                     toolErrorCode = isActionContractError(err)
                         ? err.errorCode
@@ -7511,9 +7517,16 @@ export async function runAgentLoop(opts) {
                         console.warn("Could not notify the action-change poller after a tool call", error);
                     }
                 }
-                if (executionStepIntent) {
+                if (executionStepIntent &&
+                    (executionStepDispatched || executionStepDispatchWrite)) {
                     executionStepFinalizationAttempted = true;
-                    if (toolResultLost || callEffect === "unknown") {
+                    if (!actionInvoked) {
+                        // The dispatch marker can persist while cancellation wins; it does
+                        // not prove the action handler started.
+                        await executionStepDispatchWrite?.catch(() => { });
+                        await resetAgentExecutionStepBeforeInvocation(executionStepIntent);
+                    }
+                    else if (toolResultLost || callEffect === "unknown") {
                         await markAgentExecutionStepUnknown(executionStepIntent);
                     }
                     else {
@@ -11047,6 +11060,9 @@ export function createProductionAgentHandler(options) {
                 const queuedSubmissionStore = shouldPreserveQueuedOrder
                     ? await import("../chat-threads/store.js")
                     : undefined;
+                if (ownerEmail && !isAuthorizedApprovalContinuation) {
+                    await ensureAgentToolApprovalTable();
+                }
                 // The inbox read runs under the slot lock, but its schema must be ready first.
                 await queuedSubmissionStore?.ensureChatThreadTables();
                 slot = await tryClaimRunSlot(threadId, runId, undefined, {
@@ -11069,6 +11085,15 @@ export function createProductionAgentHandler(options) {
                             hasPendingQueuedSubmission: (tx) => queuedSubmissionStore.hasPendingQueuedSubmissionReceipt(tx, runThreadId),
                         }
                         : {}),
+                    ...(ownerEmail && !isAuthorizedApprovalContinuation
+                        ? {
+                            hasPendingApproval: (tx) => hasPendingAgentToolApproval(tx, {
+                                ownerEmail,
+                                orgId: getRequestOrgId() ?? null,
+                                threadId: runThreadId,
+                            }),
+                        }
+                        : {}),
                 });
             }
             catch (error) {

package/dist/agent/reaped-run-thread.js

@@ -1,7 +1,42 @@
 import { getThread, updateThreadData, withThreadDataLock, } from "../chat-threads/store.js";
 import { RUN_NOT_STARTED_METADATA_KEY } from "../shared/agent-chat-run-not-started.js";
-import { readStoppedRunForThreadFold } from "./run-store.js";
+import { AgentRunJournalUnreadableError, readStoppedRunForThreadFold, } from "./run-store.js";
 import { buildAssistantMessage, extractThreadMeta, foldAssistantTurn, isRunPrompt, normalizeThreadRepository, } from "./thread-data-builder.js";
+function readThreadRepository(threadId, turnId, threadData) {
+    let repository;
+    try {
+        repository = JSON.parse(threadData || "{}");
+    }
+    catch (cause) {
+        throw new AgentRunJournalUnreadableError(threadId, turnId, 0, "invalid_thread_data", { cause });
+    }
+    const unreadable = (message) => new AgentRunJournalUnreadableError(threadId, turnId, 0, "invalid_thread_data", { cause: new Error(message) });
+    if (typeof repository !== "object" ||
+        repository === null ||
+        Array.isArray(repository)) {
+        throw unreadable("Stored thread data is not a repository object");
+    }
+    const messages = repository.messages;
+    if (messages !== undefined &&
+        (!Array.isArray(messages) ||
+            !messages.every((entry) => {
+                if (typeof entry !== "object" ||
+                    entry === null ||
+                    Array.isArray(entry)) {
+                    return false;
+                }
+                const storedMessage = entry.message;
+                const message = storedMessage ?? entry;
+                return (typeof message === "object" &&
+                    message !== null &&
+                    !Array.isArray(message) &&
+                    typeof message.id === "string" &&
+                    message.id.length > 0);
+            }))) {
+        throw unreadable("Stored thread data has malformed messages");
+    }
+    return normalizeThreadRepository(repository);
+}
 /**
  * Saves the reply of a run the server ended because its worker stopped
  * (a crash, a killed function) into the thread, the way a run that finishes
@@ -51,7 +86,7 @@ export async function foldReapedRunIntoThread(runId, terminalError) {
         const thread = await getThread(run.threadId);
         if (!thread)
             return "superseded";
-        const repo = normalizeThreadRepository(JSON.parse(thread.threadData || "{}"));
+        const repo = readThreadRepository(run.threadId, run.turnId, thread.threadData);
         const folded = foldAssistantTurn(repo, assistant, {
             runId,
             turnId: run.turnId,
@@ -88,7 +123,7 @@ export async function foldReapedRunIntoThread(runId, terminalError) {
                 const currentThreadData = rows[0]?.thread_data;
                 if (typeof currentThreadData !== "string")
                     return false;
-                const currentRepo = normalizeThreadRepository(JSON.parse(currentThreadData || "{}"));
+                const currentRepo = readThreadRepository(run.threadId, run.turnId, currentThreadData);
                 const last = currentRepo.messages.at(-1)?.message ?? currentRepo.messages.at(-1);
                 const ownsPrompt = last?.role === "user"
                     ? isRunPrompt(last, { runId, ...run })

package/dist/agent/run-migrations.js

@@ -139,4 +139,26 @@ export const AGENT_RUN_MIGRATIONS = [
         WHERE thread_projection_pending IS TRUE
     `,
     },
+    {
+        version: 10,
+        name: "agent-run-thread-projection-retry-fairness",
+        sql: `
+      CREATE SEQUENCE IF NOT EXISTS agent_run_projection_retry_order_seq;
+      ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_retry_order BIGINT;
+      UPDATE agent_runs
+      SET thread_projection_retry_order = nextval('agent_run_projection_retry_order_seq')
+      WHERE thread_projection_pending IS TRUE
+        AND thread_projection_retry_order IS NULL;
+      CREATE INDEX IF NOT EXISTS agent_runs_thread_projection_retry_order_idx
+        ON agent_runs (thread_projection_retry_order ASC NULLS FIRST, completed_at ASC, id ASC)
+        WHERE thread_projection_pending IS TRUE
+    `,
+    },
+    {
+        version: 11,
+        name: "agent-run-thread-projection-quarantine",
+        sql: `
+      ALTER TABLE agent_runs ADD COLUMN IF NOT EXISTS thread_projection_error_code TEXT
+    `,
+    },
 ];

package/dist/agent/run-store.d.ts

@@ -149,6 +149,7 @@ export type AgentExecutionStepAdmission = {
 /** Persist intent before dispatch and decide whether an interrupted call may run again. */
 export declare function beginAgentExecutionStep(intent: AgentExecutionStepIntent): Promise<AgentExecutionStepAdmission>;
 export declare function markAgentExecutionStepDispatched(intent: AgentExecutionStepIntent): Promise<void>;
+export declare function resetAgentExecutionStepBeforeInvocation(intent: AgentExecutionStepIntent): Promise<void>;
 export declare function completeAgentExecutionStep(intent: AgentExecutionStepIntent, resultJson: string, errorJson?: string): Promise<void>;
 export declare function markAgentExecutionStepUnknown(intent: AgentExecutionStepIntent): Promise<void>;
 /** A detached action may attach late evidence only while its lease is current. */
@@ -265,11 +266,14 @@ export declare function tryClaimRunSlot(threadId: string, runId: string, maxStal
     };
     /** Defer a fresh turn while an earlier accepted inbox submission is queued. */
     hasPendingQueuedSubmission?: (tx: DbExec) => Promise<boolean>;
+    /** Keep ordinary turns behind a pending tool approval on this thread. */
+    hasPendingApproval?: (tx: DbExec) => Promise<boolean>;
     afterInsert?: (tx: DbExec) => Promise<void>;
 }): Promise<{
     claimed: boolean;
     activeRunId: string | null;
     queuedSubmissionPending?: boolean;
+    approvalPending?: boolean;
     completedRunId?: string;
     turnAborted?: boolean;
     continueRefused?: ContinueRefusalCode;
@@ -411,6 +415,7 @@ export declare function getRunById(runId: string): Promise<{
     errorCode: string | null;
     errorDetail: string | null;
     terminalReason: string | null;
+    threadProjectionErrorCode: string | null;
 } | null>;
 /**
  * What saving a run the server ended on its behalf needs: the run's ledger,
@@ -469,6 +474,7 @@ export interface AgentRunSummary {
     dispatchMode: string | null;
     terminalReason: string | null;
     diagStage: string | null;
+    threadProjectionErrorCode: string | null;
     inFlightSince: number | null;
 }
 export declare function listRunsForThread(threadId: string, options?: {
@@ -484,9 +490,9 @@ export declare class AgentRunJournalUnreadableError extends Error {
     readonly threadId: string;
     readonly turnId: string | undefined;
     readonly rowIndex: number;
-    readonly reason: "invalid_turn" | "invalid_row" | "invalid_event_json" | "invalid_event";
+    readonly reason: "invalid_turn" | "invalid_row" | "invalid_event_json" | "invalid_event" | "invalid_thread_data" | "invalid_execution_step";
     readonly errorCode = "tool_call_journal_unreadable";
-    constructor(threadId: string, turnId: string | undefined, rowIndex: number, reason: "invalid_turn" | "invalid_row" | "invalid_event_json" | "invalid_event", options?: ErrorOptions);
+    constructor(threadId: string, turnId: string | undefined, rowIndex: number, reason: "invalid_turn" | "invalid_row" | "invalid_event_json" | "invalid_event" | "invalid_thread_data" | "invalid_execution_step", options?: ErrorOptions);
 }
 export declare function getCurrentTurnRunEventsForThread(threadId: string, knownTurnId?: string): Promise<CurrentTurnRunEvent[]>;
 export declare function getCurrentTurnRunIdsForThread(threadId: string, turnId: string): Promise<string[]>;
@@ -522,3 +528,14 @@ export declare function listErroredRuns(options?: {
     durationMs: number | null;
 }>>;
 export declare function ensureTerminalRunEvent(runId: string, event: Record<string, unknown>): Promise<void>;
+export type RunThreadProjectionRetry = {
+    state: "untracked";
+} | {
+    state: "already_projected";
+} | {
+    state: "projected";
+} | {
+    state: "deferred";
+};
+/** Retry after repairing persisted source data; until success, the marker keeps later same-turn runs gated. */
+export declare function retryRunThreadProjection(runId: string): Promise<RunThreadProjectionRetry>;

package/dist/agent/run-store.fencing.worker.js

@@ -6,7 +6,7 @@ import { toPostgresParams, withDbExec } from "../db/client.js";
 import { withMigrationRuntime } from "../db/migration-runtime.js";
 import { withExecutionFence } from "./execution-fence.js";
 import { abortRunAtSafeBoundaryDurably } from "./run-manager.js";
-import { beginAgentExecutionStep, claimTurnExecutionLease, completeAgentExecutionStep, ensureRunTables, insertRun, insertRunEvent, markAgentExecutionStepDispatched, } from "./run-store.js";
+import { beginAgentExecutionStep, claimTurnExecutionLease, completeAgentExecutionStep, ensureRunTables, insertRun, insertRunEvent, markAgentExecutionStepDispatched, persistRunCheckpointEvent, reapIfStale, } from "./run-store.js";
 import { applySubmittedUserMessage, buildUserMessage, extractThreadMeta, } from "./thread-data-builder.js";
 function executor(sql) {
     return {
@@ -115,6 +115,26 @@ async function main() {
                 }));
                 return;
             }
+            if (mode === "checkpoint-crash") {
+                const payload = JSON.parse(extra ?? "null");
+                await insertRun(runId, threadId, turnId, {
+                    dispatchMode: "background",
+                    dispatchPayload: JSON.stringify(payload),
+                });
+                const fence = await claimTurnExecutionLease(threadId, turnId, runId);
+                await withExecutionFence(fence, async () => {
+                    await insertRunEvent(runId, 0, JSON.stringify({ type: "text", text: "Completed before timeout" }));
+                    await persistRunCheckpointEvent(runId, { type: "auto_continue", reason: "run_timeout" }, "run_timeout");
+                });
+                writeSync(1, JSON.stringify({ status: "checkpointed", fence }));
+                process.exit(83);
+            }
+            if (mode === "stale-reap") {
+                await withMigrationRuntime(() => ensureChatThreadTables());
+                const reaped = await reapIfStale(runId);
+                writeSync(1, JSON.stringify({ reaped }));
+                return;
+            }
             if (mode === "durable-abort") {
                 const [{ pid }] = await sql `SELECT pg_backend_pid() AS pid`;
                 databaseBackendPid = Number(pid);