@agent-native/core 0.209.0 → 0.209.1-nightly-20261015093558

package/dist/agent/engine/continuation-dispatch-retry.js

@@ -1,20 +1,50 @@
+import { SelfDispatchHttpError } from "../../server/self-dispatch.js";
+// These statuses mean the endpoint is shedding load, not that the handoff is
+// dead. They are waited out with jittered backoff instead of spending the short
+// fixed attempt cap, which deferred the chunk to the sweep's multi-minute gap.
+const OVERLOAD_STATUSES = new Set([429, 502, 503, 504, 520]);
+const OVERLOAD_BACKOFF_BASE_MS = 1_000;
+const OVERLOAD_BACKOFF_CAP_MS = 30_000;
+const RETRY_AFTER_CLAMP_MS = 60_000;
+// Full jitter can draw ~0 forever, so the wait budget alone never drains.
+const MAX_OVERLOAD_RETRIES = 8;
+/** Delay before the next try, or null when waiting any longer is pointless. */
+function overloadBackoffMs(err, retriesSoFar, waitedMs, budgetMs, random) {
+    if (retriesSoFar >= MAX_OVERLOAD_RETRIES)
+        return null;
+    const remainingMs = budgetMs - waitedMs;
+    if (remainingMs <= 0)
+        return null;
+    const retryAfterMs = Math.min(err.retryAfterMs ?? 0, RETRY_AFTER_CLAMP_MS);
+    // The server asked for longer than this run can wait; the sweep owns it.
+    if (retryAfterMs > remainingMs)
+        return null;
+    const ceilingMs = Math.min(OVERLOAD_BACKOFF_CAP_MS, OVERLOAD_BACKOFF_BASE_MS * 2 ** retriesSoFar);
+    return Math.min(Math.max(random() * ceilingMs, retryAfterMs), remainingMs);
+}
 export async function attemptContinuationDispatch(params) {
-    const { event, backgroundContinuationCount, nextRunId, nextRowInserted, continuationDispatchPath, dispatchBody, dispatchBudget, isLoopProtectionDispatchError, maxNestedSelfDispatchDepth, deps: d, } = params;
+    const { event, backgroundContinuationCount, nextRunId, nextRowInserted, continuationDispatchPath, dispatchBody, dispatchBudget, isLoopProtectionDispatchError, maxNestedSelfDispatchDepth, deps: d, random = Math.random, now = Date.now, } = params;
     const maxDispatchAttempts = dispatchBudget.maxDispatchAttempts;
     const dispatchResponseTimeoutMs = dispatchBudget.dispatchResponseTimeoutMs;
+    const overloadWaitBudgetMs = dispatchBudget.overloadWaitBudgetMs;
     let dispatched = false;
     let lastDispatchErr;
     const nestedDepthExceeded = backgroundContinuationCount >= maxNestedSelfDispatchDepth;
     if (nestedDepthExceeded) {
         lastDispatchErr = new Error(`proactive nested-dispatch depth cap reached (backgroundContinuationCount=${backgroundContinuationCount} >= MAX_NESTED_SELF_DISPATCH_DEPTH=${maxNestedSelfDispatchDepth}) — deferring to the unclaimed-background-run sweep instead of risking Netlify loop protection`);
     }
-    for (let attempt = 0; !nestedDepthExceeded && attempt < maxDispatchAttempts && !dispatched; attempt++) {
+    const startedAt = now();
+    // Overload retries are paid for by the wait budget, not the attempt cap.
+    let overloadRetries = 0;
+    let overloadWaitedMs = 0;
+    let failedAttempts = 0;
+    let nextBackoffMs = 0;
+    for (let attempt = 0; !nestedDepthExceeded &&
+        attempt < maxDispatchAttempts + overloadRetries &&
+        !dispatched; attempt++) {
         try {
             if (attempt > 0) {
-                const backoffMs = Number.isFinite(dispatchBudget.backoffCapMs)
-                    ? Math.min(500 * 2 ** (attempt - 1), dispatchBudget.backoffCapMs)
-                    : 500 * 2 ** attempt;
-                await d.sleep(backoffMs);
+                await d.sleep(nextBackoffMs);
                 if (nextRowInserted) {
                     await d.updateRunHeartbeat(nextRunId).catch(() => { });
                 }
@@ -46,6 +76,23 @@ export async function attemptContinuationDispatch(params) {
             if (isLoopProtectionDispatchError(dispatchErr)) {
                 break;
             }
+            if (dispatchErr instanceof SelfDispatchHttpError &&
+                OVERLOAD_STATUSES.has(dispatchErr.httpStatus)) {
+                const backoffMs = overloadBackoffMs(dispatchErr, overloadRetries, 
+                // Slow overload responses spend the same host time as the sleeps.
+                Math.max(overloadWaitedMs, now() - startedAt), overloadWaitBudgetMs, random);
+                if (backoffMs === null)
+                    break;
+                overloadRetries++;
+                overloadWaitedMs += backoffMs;
+                nextBackoffMs = backoffMs;
+            }
+            else {
+                failedAttempts++;
+                nextBackoffMs = Number.isFinite(dispatchBudget.backoffCapMs)
+                    ? Math.min(500 * 2 ** (failedAttempts - 1), dispatchBudget.backoffCapMs)
+                    : 500 * 2 ** failedAttempts;
+            }
         }
     }
     return { dispatched, lastDispatchErr, nestedDepthExceeded };

package/dist/agent/harness/store.d.ts

@@ -38,6 +38,7 @@ export interface SaveAgentHarnessSessionInput {
     expectedGeneration?: number;
     existingSession?: StoredAgentHarnessSession | null;
 }
+export declare const agentHarnessSessionsStore: import("../../db/store-registry.js").Store;
 export declare function ensureAgentHarnessSessionTables(): Promise<void>;
 export declare function saveAgentHarnessSession(input: SaveAgentHarnessSessionInput): Promise<StoredAgentHarnessSession>;
 export declare function updateAgentHarnessSession(id: string, patch: Partial<Omit<SaveAgentHarnessSessionInput, "id">>): Promise<StoredAgentHarnessSession | null>;

package/dist/agent/harness/store.js

@@ -1,6 +1,6 @@
 import { getDbExec } from "../../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../../db/ddl-guard.js";
-import { retainRequestDbPoolScope } from "../../db/request-pool-context.js";
+import { defineStore } from "../../db/store-registry.js";
 export class AgentHarnessSessionConflictError extends Error {
     constructor(sessionId) {
         super(`Harness session ${sessionId} changed concurrently; retry the operation.`);
@@ -12,11 +12,13 @@ export function isAgentHarnessSessionConflictError(error) {
         (error instanceof Error &&
             error.name === "AgentHarnessSessionConflictError"));
 }
-let initPromise;
-export async function ensureAgentHarnessSessionTables() {
-    if (!initPromise) {
-        const initPromiseWithRequestDbPoolScope = (async () => {
-            const createSql = `
+export const agentHarnessSessionsStore = defineStore({
+    id: "agent_harness_sessions",
+    migrations: [
+        {
+            name: "baseline",
+            run: async () => {
+                const createSql = `
         CREATE TABLE IF NOT EXISTS agent_harness_sessions (
           id TEXT PRIMARY KEY,
           harness_name TEXT NOT NULL,
@@ -36,7 +38,6 @@ export async function ensureAgentHarnessSessionTables() {
           stopped_at BIGINT
         )
       `;
-            {
                 await ensureTableExists("agent_harness_sessions", createSql);
                 for (const col of [
                     "run_id",
@@ -55,15 +56,12 @@ export async function ensureAgentHarnessSessionTables() {
                 await ensureIndexExists("idx_agent_harness_sessions_thread", `CREATE INDEX IF NOT EXISTS idx_agent_harness_sessions_thread ON agent_harness_sessions(thread_id, updated_at)`);
                 await ensureIndexExists("idx_agent_harness_sessions_status", `CREATE INDEX IF NOT EXISTS idx_agent_harness_sessions_status ON agent_harness_sessions(status, updated_at)`);
                 await ensureIndexExists("idx_agent_harness_sessions_owner", `CREATE INDEX IF NOT EXISTS idx_agent_harness_sessions_owner ON agent_harness_sessions(owner_email, updated_at)`);
-                return;
-            }
-        })().catch((err) => {
-            initPromise = undefined;
-            throw err;
-        });
-        initPromise = retainRequestDbPoolScope(initPromiseWithRequestDbPoolScope);
-    }
-    return initPromise;
+            },
+        },
+    ],
+});
+export function ensureAgentHarnessSessionTables() {
+    return agentHarnessSessionsStore.ready();
 }
 export async function saveAgentHarnessSession(input) {
     await ensureAgentHarnessSessionTables();

package/dist/agent/observational-memory/store.d.ts

@@ -12,6 +12,7 @@
  * runtime even before the migration plugin is registered.
  */
 import type { ObservationalMemoryEntry, ObservationalMemoryOwner, ObservationalMemoryTier } from "./types.js";
+export declare const observationalMemoryStore: import("../../db/store-registry.js").Store;
 export declare function ensureTable(): Promise<void>;
 export declare function __resetObservationalMemoryTableCache(): void;
 export interface InsertObservationalMemoryInput extends ObservationalMemoryOwner {

package/dist/agent/observational-memory/store.js

@@ -13,15 +13,16 @@
  */
 import { getDbExec } from "../../db/client.js";
 import { ensureTableExists, ensureIndexExists } from "../../db/ddl-guard.js";
-import { retainRequestDbPoolScope } from "../../db/request-pool-context.js";
+import { defineStore } from "../../db/store-registry.js";
 import { widenIntColumnsToBigInt } from "../../db/widen-columns.js";
-let tableReady = null;
-export async function ensureTable() {
-    if (tableReady)
-        return tableReady;
-    tableReady = retainRequestDbPoolScope((async () => {
-        const integerType = "BIGINT";
-        const createSql = `CREATE TABLE IF NOT EXISTS observational_memory (
+export const observationalMemoryStore = defineStore({
+    id: "observational_memory",
+    migrations: [
+        {
+            name: "baseline",
+            run: async () => {
+                const integerType = "BIGINT";
+                const createSql = `CREATE TABLE IF NOT EXISTS observational_memory (
         id TEXT PRIMARY KEY,
         thread_id TEXT NOT NULL,
         tier TEXT NOT NULL,
@@ -36,26 +37,29 @@ export async function ensureTable() {
         org_id TEXT,
         visibility TEXT NOT NULL DEFAULT 'private'
       )`;
-        {
-            await ensureTableExists("observational_memory", createSql);
-            await widenIntColumnsToBigInt("observational_memory", [
-                "created_at",
-                "updated_at",
-            ]);
-            await ensureIndexExists("observational_memory_thread_tier_idx", `CREATE INDEX IF NOT EXISTS observational_memory_thread_tier_idx
+                await ensureTableExists("observational_memory", createSql);
+                await ensureIndexExists("observational_memory_thread_tier_idx", `CREATE INDEX IF NOT EXISTS observational_memory_thread_tier_idx
           ON observational_memory(thread_id, tier, created_at)`);
-            await ensureIndexExists("observational_memory_thread_owner_idx", `CREATE INDEX IF NOT EXISTS observational_memory_thread_owner_idx
+                await ensureIndexExists("observational_memory_thread_owner_idx", `CREATE INDEX IF NOT EXISTS observational_memory_thread_owner_idx
           ON observational_memory(thread_id, owner_email)`);
-            return;
-        }
-    })().catch((err) => {
-        tableReady = null;
-        throw err;
-    }));
-    return tableReady;
+            },
+        },
+        {
+            name: "widen-bigint",
+            run: async () => {
+                await widenIntColumnsToBigInt("observational_memory", [
+                    "created_at",
+                    "updated_at",
+                ]);
+            },
+        },
+    ],
+});
+export function ensureTable() {
+    return observationalMemoryStore.ready();
 }
 export function __resetObservationalMemoryTableCache() {
-    tableReady = null;
+    observationalMemoryStore.reset();
 }
 function entryId() {
     return `om-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;

package/dist/agent/production-agent.d.ts

@@ -187,6 +187,8 @@ export interface ActionEntry {
     persistInBrowser?: boolean;
     changeResource?: (input: any, result: any) => import("../action.js").ActionChangeResource | null | undefined;
     parallelSafe?: boolean;
+    /** See `ActionDefinition.retrySafe`. */
+    retrySafe?: boolean | ((input: any) => boolean);
     dedupe?: boolean;
     toolCallable?: boolean;
     agentDiscoveryAvailable?: (context?: import("../action.js").ActionRunContext) => boolean | Promise<boolean>;
@@ -357,7 +359,12 @@ export interface ProductionAgentOptions {
     runNoProgressTimeoutMs?: number;
     durableBackgroundRuns?: boolean;
     onRunStart?: (send: (event: AgentChatEvent) => void, threadId: string, runId: string) => void | Promise<void>;
-    onEngineResolved?: (engine: AgentEngine, model: string) => void;
+    /**
+     * Called when the run's engine, model, and effort resolve, and again before
+     * each model call, because a call can run on a rate-limit fallback model or
+     * at the lower effort an empty-response retry steps down to.
+     */
+    onEngineResolved?: (engine: AgentEngine, model: string, reasoningEffort: ReasoningEffort | undefined) => void;
     resolveOwnerEmail?: (event: any) => string | Promise<string>;
     finalResponseGuard?: AgentLoopFinalResponseGuard;
     skipFilesContext?: boolean;
@@ -674,6 +681,12 @@ export declare function runAgentLoop(opts: {
     unknownWriteToolNames?: Set<string>;
     internalContinuation?: boolean;
     onModelInput?: ModelInputObserver;
+    /**
+     * The model and effort each model call uses. Either can change mid-run: a
+     * rate limit falls back to another model, and an empty response steps effort
+     * down.
+     */
+    onModelSettings?: (model: string, reasoningEffort: ReasoningEffort | undefined) => void;
     onUsage?: (usage: AgentLoopUsage) => void;
     onOutcome?: (outcome: AgentLoopOutcome) => void;
     ownerEmail?: string | null;
@@ -864,6 +877,8 @@ export interface ContinuationDispatchBudget {
     maxDispatchAttempts: number;
     dispatchResponseTimeoutMs: number;
     backoffCapMs: number;
+    /** Total sleep allowed while the target answers 429/502/503/504/520. */
+    overloadWaitBudgetMs: number;
 }
 export declare function resolveContinuationDispatchBudget(opts: {
     chainViaDurableBackground: boolean;

package/dist/agent/production-agent.js

@@ -5,7 +5,7 @@ import Ajv2020 from "ajv/dist/2020.js";
 import { defineEventHandler, getHeader, setResponseHeader, setResponseStatus, getMethod, } from "h3";
 import "../authorization/check-action.js";
 import { parseA2AAgentActivityPart } from "../a2a/activity.js";
-import { actionCallEmitsChange, actionCallIsReadOnly, actionChangeResource, } from "../action-call-classification.js";
+import { actionCallEmitsChange, actionCallIsReadOnly, actionCallIsRetrySafe, actionChangeResource, } from "../action-call-classification.js";
 import { ACTION_CHAT_UI_RECORD_CHANGE_RENDERER, normalizeActionChangeResult, } from "../action-ui.js";
 import { AgentConnectionRequiredError, describeToolParameterSignature, isActionContractError, runActionWithExecutionOutcome, isActionHiddenFromEveryAgentSurface, isAgentActionStopError, isAgentConnectionRequiredError, stripUnsupportedSchemaKeywords, } from "../action.js";
 import { getAppConfig } from "../app-config/index.js";
@@ -4584,6 +4584,7 @@ export async function runAgentLoop(opts) {
                         : effectiveReasoningEffort,
                     providerOptions,
                 };
+                opts.onModelSettings?.(model, effectiveReasoningEffort);
                 usage.llmCalls = (usage.llmCalls ?? 0) + 1;
                 notifyModelInputObserver(opts.onModelInput, engineMessages);
                 const eventStream = engine.stream(streamOpts);
@@ -4952,7 +4953,7 @@ export async function runAgentLoop(opts) {
                         fallbackModelAttempted = true;
                         send({
                             type: "activity",
-                            label: `${model} is rate limited — switching to ${fallbackModel}`,
+                            label: "Model is rate limited — switching to a backup model",
                         });
                         send({ type: "clear" });
                         model = fallbackModel;
@@ -4961,7 +4962,9 @@ export async function runAgentLoop(opts) {
                         usage.cacheReadTokens = 0;
                         usage.cacheWriteTokens = 0;
                         usage.model = fallbackModel;
-                        retry = -1;
+                        // The sibling shares the throttled quota, so it gets this one
+                        // attempt; a fresh retry budget only re-hits the same limit.
+                        retry = maxRetriesForError(err) - 1;
                         continue;
                     }
                 }
@@ -5322,6 +5325,9 @@ export async function runAgentLoop(opts) {
             const actionIsReadOnly = actionEntry
                 ? actionCallIsReadOnly(actionEntry, toolCall.input, false)
                 : false;
+            const actionRetrySafe = actionEntry
+                ? actionCallIsRetrySafe(actionEntry, toolCall.input)
+                : false;
             const repeatGuardStopFromThisCall = noteRepeatedToolCall(toolCall.name, toolCall.input, toolCall.id);
             const rollbackRepeatedToolCall = () => {
                 const repeatKey = toolCallCacheKey(toolCall.name, toolCall.input);
@@ -5355,6 +5361,14 @@ export async function runAgentLoop(opts) {
             const emitToolDone = (event) => {
                 if (event.outcomeUnknown) {
                     unknownWriteToolNames.add(toolCall.name);
+                }
+                // A write that errored after it was invoked may still have committed,
+                // retry-safe or not, so cached reads of its target are stale.
+                if (event.outcomeUnknown ||
+                    (event.isError &&
+                        actionInvoked &&
+                        !actionIsReadOnly &&
+                        !actionRefused)) {
                     readOnlyToolResultCache.clear();
                     duplicateReadOnlyToolCalls.clear();
                 }
@@ -5784,8 +5798,8 @@ export async function runAgentLoop(opts) {
                     });
                     recordToolResult(result, true);
                     requestedActionStop ??= {
-                        message: `I stopped because the ${toolCall.name} action was interrupted ${priorInterruptions} time(s) and its result is unknown. ` +
-                            `Check whether it completed before asking me to retry.`,
+                        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",
                     };
                     return {
@@ -5930,6 +5944,10 @@ export async function runAgentLoop(opts) {
                 let result;
                 let chatUIResult;
                 let isError = false;
+                // A deadline or abort after invocation leaves a zombie that may still
+                // commit, so a retry-safe action stays blocked for it; an error the
+                // handler returned does not.
+                let toolResultLost = false;
                 let toolErrorCode;
                 let mcpApp;
                 let toolResultImages;
@@ -6001,7 +6019,7 @@ export async function runAgentLoop(opts) {
                             ...(opts.turnId ? { turnId: opts.turnId } : {}),
                         };
                         actionInvoked = true;
-                        return runActionWithExecutionOutcome(actionEntry.run, toolCall.input, actionContext, actionExecutionOutcome);
+                        return runActionWithExecutionOutcome(actionEntry.run, toolCall.input, actionContext, actionExecutionOutcome, actionEntry);
                     };
                     const actionPromise = Promise.resolve(runWithRequestContext({
                         ...(requestContext ?? {}),
@@ -6179,6 +6197,9 @@ export async function runAgentLoop(opts) {
                 }
                 catch (err) {
                     actionRefused = actionExecutionOutcome.refused;
+                    toolResultLost =
+                        signal.aborted ||
+                            isToolCallTimeoutResult(String(err?.message ?? err));
                     toolErrorCode = isActionContractError(err)
                         ? err.errorCode
                         : undefined;
@@ -6286,7 +6307,10 @@ export async function runAgentLoop(opts) {
                     ...(isError ? { isError: true } : {}),
                     ...(toolErrorCode ? { errorCode: toolErrorCode } : {}),
                     ...(isError
-                        ? actionInvoked && !actionIsReadOnly && !actionRefused
+                        ? actionInvoked &&
+                            !actionIsReadOnly &&
+                            !actionRefused &&
+                            (!actionRetrySafe || toolResultLost)
                             ? { outcomeUnknown: true }
                             : { completedSideEffect: false }
                         : receipt
@@ -7389,6 +7413,9 @@ export function resolveContinuationDispatchBudget(opts) {
             maxDispatchAttempts: 3,
             dispatchResponseTimeoutMs: 15_000,
             backoffCapMs: Infinity,
+            // Durable-background chaining is entered from the foreground function,
+            // which a host kills about 60s in, so it waits no longer than that tier.
+            overloadWaitBudgetMs: 10_000,
         };
     }
     if (opts.workerProvenInBackgroundFunction) {
@@ -7396,12 +7423,17 @@ export function resolveContinuationDispatchBudget(opts) {
             maxDispatchAttempts: 5,
             dispatchResponseTimeoutMs: 15_000,
             backoffCapMs: 4_000,
+            // The chain starts 2 minutes before the 15-minute background budget;
+            // five hung dispatches plus backoff already take about 82s of that.
+            overloadWaitBudgetMs: 30_000,
         };
     }
+    // A hosted foreground function is killed soon after its soft timeout.
     return {
         maxDispatchAttempts: 2,
         dispatchResponseTimeoutMs: 10_000,
         backoffCapMs: Infinity,
+        overloadWaitBudgetMs: 10_000,
     };
 }
 export function isLoopProtectionDispatchError(err) {
@@ -8539,7 +8571,7 @@ export function createProductionAgentHandler(options) {
             configuredEffort: options.reasoningEffort,
         });
         const modelSupportsVision = isAgentModelVisionCapable(effectiveModel, engine.capabilities.vision === true);
-        options.onEngineResolved?.(engine, effectiveModel);
+        options.onEngineResolved?.(engine, effectiveModel, reasoningEffort);
         console.log(`[agent-chat] resolved engine=${engine.name} model=${effectiveModel} requestModel=${requestModel ?? "(none)"} requestEngine=${requestEngine ?? "(none)"} modelSource=${modelSelectionSource} engineDefault=${engine.defaultModel} effort=${reasoningEffort ?? "unset"} turnId=${requestTurnId ?? "(none)"}`);
         if (!(await isResolvedEngineUsableForRequest(engine, {
             apiKey: effectiveApiKey,
@@ -9792,9 +9824,26 @@ export function createProductionAgentHandler(options) {
                                 : "") +
                             `\n</custom-agent-profile>`;
                         let responseText = "";
-                        const subUsage = await runAgentLoop({
+                        // A profile is its own model conversation running beside
+                        // others, so it gets its own run context: its model and effort
+                        // never stand in for another loop's, and it starts with
+                        // nothing read, since the run's reads are what the run's
+                        // model saw. New per-conversation fields reset here too.
+                        const profileRun = {
+                            ...getRequestRunContext(),
+                            model: profile.model ?? model,
+                            reasoningEffort,
+                            toolSearchReads: undefined,
+                            extensionContentReads: undefined,
+                            extensionExcerptReads: undefined,
+                        };
+                        const profileLoopOpts = {
                             engine,
                             model: profile.model ?? model,
+                            onModelSettings: (loopModel, effort) => {
+                                profileRun.model = loopModel;
+                                profileRun.reasoningEffort = effort;
+                            },
                             systemPrompt: profilePrompt,
                             tools: requestTools,
                             availableTools: availableRequestTools,
@@ -9848,7 +9897,8 @@ export function createProductionAgentHandler(options) {
                             ...(resolvedRunSoftTimeoutMs > 0
                                 ? { runSoftTimeoutMs: resolvedRunSoftTimeoutMs }
                                 : {}),
-                        });
+                        };
+                        const subUsage = await runWithRequestContext({ ...getRequestContext(), run: profileRun }, () => runAgentLoop(profileLoopOpts));
                         await control.flushEvents();
                         try {
                             const ownerEmail = options.resolveOwnerEmail
@@ -9968,6 +10018,9 @@ export function createProductionAgentHandler(options) {
             const agentLoopOpts = {
                 engine,
                 model: effectiveModel,
+                // Custom agent profile loops report into their own run context
+                // copies, so only this loop sets the run's model and effort.
+                onModelSettings: (model, effort) => options.onEngineResolved?.(engine, model, effort),
                 runId,
                 followUpSuggestions: true,
                 systemPrompt: requestSystemPrompt,

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

@@ -97,6 +97,7 @@ export declare class AgentTurnInitiatorMismatchError extends Error {
 export declare class AgentTurnInitiatorUnavailableError extends Error {
     constructor(threadId: string, turnId: string);
 }
+export declare const agentRunsStore: import("../db/store-registry.js").Store;
 export declare function ensureRunTables(): Promise<void>;
 /**
  * Persist a zombie tool-call completion to the ledger. Called by the detached