stitchkit 0.56.4 → 0.57.0

package/dist/agent-runtime.js

@@ -2,6 +2,34 @@ import {
   ToolExecutionControlError,
   isToolExecutionControlError
 } from "./index-sa2mbwa7.js";
+import {
+  AgentAssistantPlaceholderSchema,
+  AgentControlPartSchema,
+  AgentCostValueSchema,
+  AgentFilePartSchema,
+  AgentJsonObjectSchema,
+  AgentMessagePartSchema,
+  AgentMessageRoleSchema,
+  AgentMessageSchema,
+  AgentMessageStatusSchema,
+  AgentOpaquePartSchema,
+  AgentProviderEnvelopeSchema,
+  AgentReasoningPartSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunMetricsSchema,
+  AgentRunSchema,
+  AgentRunStateSchema,
+  AgentSnapshotSchema,
+  AgentSourcePartSchema,
+  AgentTerminalReasonSchema,
+  AgentTextPartSchema,
+  AgentTimestampSchema,
+  AgentToolCallPartSchema,
+  AgentToolResultPartSchema,
+  AgentUsageSchema,
+  AgentUsageValueSchema
+} from "./index-1f4fcj0b.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -226,196 +254,82 @@ function createAgentSessionCoordinator() {
   };
 }
 // src/agent-runtime/events.ts
-import { z as z2 } from "zod";
-
-// src/agent-runtime/schemas.ts
 import { z } from "zod";
-var AgentRecordIdSchema = z.string().min(1);
-var AgentRecordVersionSchema = z.int().nonnegative();
-var AgentTimestampSchema = z.iso.datetime({ offset: true });
-var AgentJsonObjectSchema = z.record(z.string(), z.json());
-var AgentProviderEnvelopeSchema = z.object({
-  schemaVersion: z.int().positive(),
-  provider: z.string().min(1),
-  data: AgentJsonObjectSchema
-});
-var AgentTextPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string()
-});
-var AgentReasoningPartSchema = z.object({
-  type: z.literal("reasoning"),
-  text: z.string(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentFilePartSchema = z.object({
-  type: z.literal("file"),
-  mediaType: z.string().min(1),
-  reference: z.string().min(1),
-  filename: z.string().min(1).optional()
-});
-var AgentSourcePartSchema = z.object({
-  type: z.literal("source"),
-  sourceId: z.string().min(1),
-  url: z.url().optional(),
-  title: z.string().optional()
-});
-var AgentToolCallPartSchema = z.object({
-  type: z.literal("tool-call"),
-  callId: z.string().min(1),
-  toolName: z.string().min(1),
-  input: z.json(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentToolResultPartSchema = z.object({
-  type: z.literal("tool-result"),
-  callId: z.string().min(1),
-  toolName: z.string().min(1),
-  outcome: z.enum(["success", "error", "interrupted"]),
-  output: z.json().optional()
-});
-var AgentOpaquePartSchema = z.object({
-  type: z.literal("provider"),
-  envelope: AgentProviderEnvelopeSchema
-});
-var AgentControlPartSchema = z.object({
-  type: z.literal("control"),
-  reason: z.enum(["run-interrupted", "stale-run"])
-});
-var AgentMessagePartSchema = z.discriminatedUnion("type", [
-  AgentTextPartSchema,
-  AgentReasoningPartSchema,
-  AgentFilePartSchema,
-  AgentSourcePartSchema,
-  AgentToolCallPartSchema,
-  AgentToolResultPartSchema,
-  AgentOpaquePartSchema,
-  AgentControlPartSchema
-]);
-var AgentMessageRoleSchema = z.enum(["user", "assistant", "system", "summary"]);
-var AgentMessageStatusSchema = z.enum([
-  "committed",
-  "streaming",
-  "completed",
-  "interrupted",
-  "failed"
-]);
-var AgentMessageSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema.optional(),
-  role: AgentMessageRoleSchema,
-  status: AgentMessageStatusSchema,
-  parts: z.array(AgentMessagePartSchema),
-  metadata: AgentJsonObjectSchema.optional(),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
-});
-var AgentRunStateSchema = z.enum([
-  "queued",
-  "running",
-  "interrupt_requested",
-  "completed",
-  "interrupted",
-  "failed",
-  "cancelled",
-  "abandoned"
-]);
-var AgentTerminalReasonSchema = z.enum([
-  "success",
-  "policy_stop",
-  "interrupted",
-  "cancelled",
-  "timeout",
-  "shutdown",
-  "provider_failure",
-  "tool_failure",
-  "abandoned"
-]);
-var AgentRunSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
+var AgentAdmissionEventSchema = z.object({
+  type: z.literal("admission"),
+  eventId: AgentRecordIdSchema,
   conversationId: AgentRecordIdSchema,
-  inputMessageIds: z.array(AgentRecordIdSchema).min(1),
-  assistantMessageId: AgentRecordIdSchema,
-  state: AgentRunStateSchema,
-  revision: AgentRecordVersionSchema,
-  ownerId: z.string().min(1).optional(),
-  terminalReason: AgentTerminalReasonSchema.optional(),
-  terminalPolicyName: z.string().min(1).optional(),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
+  runId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
+  emittedAt: AgentTimestampSchema
 });
-var AgentSnapshotSchema = z.object({
-  schemaVersion: z.literal(1),
+var EventIdentitySchema = z.object({
   conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  messages: z.array(AgentMessageSchema),
-  runs: z.array(AgentRunSchema)
+  runId: AgentRecordIdSchema,
+  emittedAt: AgentTimestampSchema
 });
-var AgentUsageValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
+var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
+  type: z.literal("assistant-delta"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  textDelta: z.string()
 });
-var AgentCostValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  currency: z.string().length(3).optional(),
-  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
+var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  provider: AgentProviderEnvelopeSchema.optional()
 });
-var AgentUsageSchema = z.object({
-  inputTokens: AgentUsageValueSchema,
-  outputTokens: AgentUsageValueSchema,
-  reasoningTokens: AgentUsageValueSchema.optional(),
-  cacheReadTokens: AgentUsageValueSchema.optional(),
-  cacheWriteTokens: AgentUsageValueSchema.optional(),
-  cost: AgentCostValueSchema.optional()
+var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-start")
 });
-
-// src/agent-runtime/events.ts
-var EventIdentitySchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  emittedAt: AgentTimestampSchema
+var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-delta"),
+  textDelta: z.string()
 });
-var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-delta"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  textDelta: z2.string()
+var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-end")
 });
 var AgentCheckpointEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-checkpoint"),
+  type: z.literal("assistant-checkpoint"),
   eventId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
-  message: AgentMessageSchema
+  message: AgentMessageSchema,
+  metrics: AgentRunMetricsSchema.optional()
 });
 var AgentRunStateEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("run-state"),
+  type: z.literal("run-state"),
   eventId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
   state: AgentRunStateSchema
 });
 var AgentToolStatusEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("tool-status"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
+  type: z.literal("tool-status"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
   callId: AgentRecordIdSchema,
-  toolName: z2.string().min(1),
-  status: z2.enum(["started", "completed", "failed", "interrupted"]),
-  input: z2.json().optional(),
-  output: z2.json().optional()
+  toolName: z.string().min(1),
+  status: z.enum(["started", "completed", "failed", "interrupted"]),
+  input: z.json().optional(),
+  output: z.json().optional()
 });
 var AgentTerminalEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("terminal"),
+  type: z.literal("terminal"),
   eventId: AgentRecordIdSchema,
   snapshotVersion: AgentRecordVersionSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z2.string().min(1).optional(),
-  message: AgentMessageSchema
+  policyName: z.string().min(1).optional(),
+  message: AgentMessageSchema,
+  metrics: AgentRunMetricsSchema.optional()
 });
-var AgentRuntimeEventSchema = z2.discriminatedUnion("type", [
+var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
+  AgentAdmissionEventSchema,
   AgentTransientDeltaEventSchema,
+  AgentReasoningStartEventSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
   AgentCheckpointEventSchema,
   AgentRunStateEventSchema,
   AgentToolStatusEventSchema,
@@ -547,15 +461,15 @@ function createAgentToolFenceLifecycle(config) {
   };
 }
 // src/agent-runtime/models.ts
-import { z as z3 } from "zod";
-var AgentModelCapabilitySchema = z3.enum(["tools", "vision", "reasoning", "files"]);
-var AgentModelDescriptorSchema = z3.object({
-  provider: z3.string().min(1),
-  modelId: z3.string().min(1),
-  contextWindow: z3.int().positive(),
-  capabilities: z3.array(AgentModelCapabilitySchema),
-  observedAt: z3.iso.datetime({ offset: true }).optional(),
-  source: z3.string().min(1).optional()
+import { z as z2 } from "zod";
+var AgentModelCapabilitySchema = z2.enum(["tools", "vision", "reasoning", "files"]);
+var AgentModelDescriptorSchema = z2.object({
+  provider: z2.string().min(1),
+  modelId: z2.string().min(1),
+  contextWindow: z2.int().positive(),
+  capabilities: z2.array(AgentModelCapabilitySchema),
+  observedAt: z2.iso.datetime({ offset: true }).optional(),
+  source: z2.string().min(1).optional()
 });
 function defineModelRegistry(config) {
   const descriptors = new Map;
@@ -595,25 +509,25 @@ function defineModelRegistry(config) {
   };
 }
 // src/agent-runtime/observability.ts
-import { z as z4 } from "zod";
-var AgentRunEventSchema = z4.object({
-  schemaVersion: z4.literal(1),
+import { z as z3 } from "zod";
+var AgentRunEventSchema = z3.object({
+  schemaVersion: z3.literal(1),
   eventId: AgentRecordIdSchema,
-  type: z4.enum(["run-started", "step-finished", "run-terminal"]),
+  type: z3.enum(["run-started", "step-finished", "run-terminal"]),
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
-  traceId: z4.string().min(1),
-  spanId: z4.string().min(1),
-  parentSpanId: z4.string().min(1).optional(),
+  traceId: z3.string().min(1),
+  spanId: z3.string().min(1),
+  parentSpanId: z3.string().min(1).optional(),
   state: AgentRunStateSchema,
   terminalReason: AgentTerminalReasonSchema.optional(),
-  modelId: z4.string().min(1).optional(),
-  step: z4.int().nonnegative().optional(),
-  queueWaitMs: z4.number().nonnegative().optional(),
-  durationMs: z4.number().nonnegative().optional(),
-  ttftMs: z4.number().nonnegative().optional(),
+  modelId: z3.string().min(1).optional(),
+  step: z3.int().nonnegative().optional(),
+  queueWaitMs: z3.number().nonnegative().optional(),
+  durationMs: z3.number().nonnegative().optional(),
+  ttftMs: z3.number().nonnegative().optional(),
   usage: AgentUsageSchema.optional(),
-  internalCause: z4.unknown().optional(),
+  internalCause: z3.unknown().optional(),
   emittedAt: AgentTimestampSchema
 });
 function createAgentObservability(config) {
@@ -638,10 +552,10 @@ function createAgentObservability(config) {
   };
 }
 // src/agent-runtime/prompt.ts
-import { z as z5 } from "zod";
-var AgentTokenCountSchema = z5.object({
-  value: z5.int().nonnegative().optional(),
-  provenance: z5.enum(["measured", "estimated", "unavailable"])
+import { z as z4 } from "zod";
+var AgentTokenCountSchema = z4.object({
+  value: z4.int().nonnegative().optional(),
+  provenance: z4.enum(["measured", "estimated", "unavailable"])
 });
 function knownValue(value) {
   return value.provenance === "unavailable" ? undefined : value.value;
@@ -720,7 +634,7 @@ import {
   stepCountIs,
   streamText
 } from "ai";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 class AgentRuntimeConflictError extends Error {
   constructor(operation) {
     super(`Agent runtime store conflict during ${operation}`);
@@ -739,7 +653,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z6.json().safeParse(value);
+  const parsed = z5.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -984,6 +898,12 @@ function createAgentRuntime(config) {
         assistant
       }), "assistant checkpoint");
       run = findRun(snapshot.runs, run.id);
+      const checkpointMetrics = {
+        partial: true,
+        durationMs: performance.now() - runStartedAt,
+        ...usage && { usage },
+        ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
+      };
       await publish({
         type: "assistant-checkpoint",
         eventId: generateId(),
@@ -991,6 +911,7 @@ function createAgentRuntime(config) {
         runId: run.id,
         snapshotVersion: snapshot.version,
         message: assistant,
+        metrics: checkpointMetrics,
         emittedAt: now().toISOString()
       });
     };
@@ -1102,11 +1023,42 @@ function createAgentRuntime(config) {
         } else if (part.type === "reasoning-start") {
           reasoningPartIndex = undefined;
           updateReasoning("", part.providerMetadata);
+          const provider = providerEnvelope(part.providerMetadata);
+          await publish({
+            type: "reasoning-start",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            ...provider && { provider },
+            emittedAt: now().toISOString()
+          });
         } else if (part.type === "reasoning-delta") {
           updateReasoning(part.text, part.providerMetadata);
+          const provider = providerEnvelope(part.providerMetadata);
+          await publish({
+            type: "reasoning-delta",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            textDelta: part.text,
+            ...provider && { provider },
+            emittedAt: now().toISOString()
+          });
         } else if (part.type === "reasoning-end") {
           updateReasoning("", part.providerMetadata);
           reasoningPartIndex = undefined;
+          const provider = providerEnvelope(part.providerMetadata);
+          await publish({
+            type: "reasoning-end",
+            conversationId: run.conversationId,
+            runId: run.id,
+            runtimeEpoch,
+            sequence,
+            ...provider && { provider },
+            emittedAt: now().toISOString()
+          });
         } else if (part.type === "tool-call") {
           const provider = providerEnvelope(part.providerMetadata);
           parts.push(AgentMessagePartSchema.parse({
@@ -1329,6 +1281,12 @@ function createAgentRuntime(config) {
       ...terminalPolicyName && { policyName: terminalPolicyName }
     }), "terminal commit");
     run = findRun(snapshot.runs, run.id);
+    const terminalMetrics = {
+      partial: false,
+      durationMs: performance.now() - runStartedAt,
+      ...usage && { usage },
+      ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
+    };
     config.observe?.emit({
       schemaVersion: 1,
       eventId: generateId(),
@@ -1341,7 +1299,7 @@ function createAgentRuntime(config) {
       state: run.state,
       terminalReason,
       ...selectedModel && { modelId: selectedModel.descriptor.modelId },
-      durationMs: performance.now() - runStartedAt,
+      durationMs: terminalMetrics.durationMs,
       ...usage && { usage },
       ...internalCause !== undefined && { internalCause },
       ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
@@ -1356,6 +1314,7 @@ function createAgentRuntime(config) {
       reason: terminalReason,
       ...terminalPolicyName && { policyName: terminalPolicyName },
       message: assistant,
+      metrics: terminalMetrics,
       emittedAt: now().toISOString()
     });
     return {
@@ -1363,9 +1322,38 @@ function createAgentRuntime(config) {
       message: assistant,
       reason: terminalReason,
       snapshotVersion: snapshot.version,
+      metrics: terminalMetrics,
       ...terminalPolicyName && { policyName: terminalPolicyName }
     };
   };
+  const resume = (rawInput) => {
+    const context = config.protocol.parseContext(rawInput.context);
+    const accepted = Promise.withResolvers();
+    const result = Promise.withResolvers();
+    (async () => {
+      try {
+        const snapshot = await config.store.loadSnapshot(rawInput.conversationId);
+        const recoveredRun = findRun(snapshot.runs, rawInput.runId);
+        if (recoveredRun.state !== "queued") {
+          throw new Error("Only a queued recovered agent run can be resumed");
+        }
+        accepted.resolve();
+        const ticket = coordinator.submit({
+          key: rawInput.conversationKey ?? rawInput.conversationId,
+          policy: "queue",
+          create: (signal) => ({
+            runId: recoveredRun.id,
+            execute: () => executeRun({ acceptedRun: recoveredRun, context, signal })
+          })
+        });
+        ticket.result.then(result.resolve, result.reject);
+      } catch (error) {
+        accepted.reject(error);
+        result.reject(error);
+      }
+    })();
+    return { accepted: accepted.promise, result: result.promise };
+  };
   return {
     submit(rawInput) {
       const metadata = rawInput.metadata === undefined ? undefined : config.protocol.parseInputMetadata(rawInput.metadata);
@@ -1456,10 +1444,41 @@ function createAgentRuntime(config) {
           const acceptedSnapshot = appliedSnapshot(acceptance, "input acceptance");
           const assignedRunId = acceptance.outcome === "duplicate" ? acceptance.runId : reservation?.admission.runId ?? runId;
           const acceptedRun = findRun(acceptedSnapshot.runs, assignedRunId);
-          outerAdmission.resolve({
+          const actualInputMessageId = acceptance.outcome === "duplicate" ? acceptance.inputMessageId : userMessage2.id;
+          const acceptedInput = acceptance.outcome === "duplicate" ? acceptance.input : acceptedSnapshot.messages.find((candidate) => candidate.id === actualInputMessageId);
+          if (!acceptedInput) {
+            throw new AgentRuntimeConflictError("admission input projection");
+          }
+          const assistantPlaceholder = AgentAssistantPlaceholderSchema.parse({
+            schemaVersion: 1,
+            id: acceptedRun.assistantMessageId,
+            conversationId: acceptedRun.conversationId,
+            runId: acceptedRun.id,
+            status: "pending",
+            createdAt: acceptedRun.createdAt,
+            updatedAt: acceptedRun.updatedAt
+          });
+          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptedSnapshot.messages.find((candidate) => candidate.id === acceptedRun.assistantMessageId) ?? assistantPlaceholder : assistantPlaceholder;
+          const admission = {
+            inputMessageId: acceptedInput.id,
             runId: acceptedRun.id,
-            assistantMessageId: acceptedRun.assistantMessageId,
+            assistantMessageId: assistantPlaceholder.id,
+            input: acceptedInput,
+            run: acceptedRun,
+            assistant: acceptedAssistant,
             snapshotVersion: acceptedSnapshot.version
+          };
+          outerAdmission.resolve(admission);
+          await publish({
+            type: "admission",
+            eventId: generateId(),
+            conversationId: acceptedRun.conversationId,
+            runId: acceptedRun.id,
+            snapshotVersion: acceptedSnapshot.version,
+            input: acceptedInput,
+            run: acceptedRun,
+            assistant: acceptedAssistant,
+            emittedAt: now().toISOString()
           });
           await publish({
             type: "run-state",
@@ -1548,34 +1567,7 @@ function createAgentRuntime(config) {
       })();
       return publicTicket;
     },
-    resume(rawInput) {
-      const context = config.protocol.parseContext(rawInput.context);
-      const accepted = Promise.withResolvers();
-      const result = Promise.withResolvers();
-      (async () => {
-        try {
-          const snapshot = await config.store.loadSnapshot(rawInput.conversationId);
-          const recoveredRun = findRun(snapshot.runs, rawInput.runId);
-          if (recoveredRun.state !== "queued") {
-            throw new Error("Only a queued recovered agent run can be resumed");
-          }
-          accepted.resolve();
-          const ticket = coordinator.submit({
-            key: rawInput.conversationKey ?? rawInput.conversationId,
-            policy: "queue",
-            create: (signal) => ({
-              runId: recoveredRun.id,
-              execute: () => executeRun({ acceptedRun: recoveredRun, context, signal })
-            })
-          });
-          ticket.result.then(result.resolve, result.reject);
-        } catch (error) {
-          accepted.reject(error);
-          result.reject(error);
-        }
-      })();
-      return { accepted: accepted.promise, result: result.promise };
-    },
+    resume,
     async interrupt(input) {
       const snapshot = await config.store.loadSnapshot(input.conversationId);
       const run = findRun(snapshot.runs, input.runId);
@@ -1599,101 +1591,298 @@ function createAgentRuntime(config) {
       }
       return requested;
     },
+    async recover(options) {
+      if (!config.store.scanRecoverablePage) {
+        throw new Error("The configured agent store does not support bounded recovery scans");
+      }
+      const pageSize = options.pageSize ?? 100;
+      const maxRuns = options.maxRuns ?? 1000;
+      if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 1000) {
+        throw new TypeError("Recovery pageSize must be an integer between 1 and 1000");
+      }
+      if (!Number.isSafeInteger(maxRuns) || maxRuns < 1) {
+        throw new TypeError("Recovery maxRuns must be a positive safe integer");
+      }
+      const outcomes = [];
+      let cursor;
+      while (outcomes.length < maxRuns && !options.signal?.aborted) {
+        const page = await config.store.scanRecoverablePage({
+          ...cursor && { cursor },
+          limit: Math.min(pageSize, maxRuns - outcomes.length)
+        });
+        for (const item of page.items) {
+          if (options.signal?.aborted)
+            break;
+          try {
+            if (item.run.state === "queued") {
+              const snapshot = await config.store.loadSnapshot(item.conversationId);
+              const blockedByAcquiredPredecessor = snapshot.runs.some((run) => run.id !== item.run.id && (run.state === "running" || run.state === "interrupt_requested"));
+              if (blockedByAcquiredPredecessor) {
+                outcomes.push({
+                  conversationId: item.conversationId,
+                  runId: item.run.id,
+                  outcome: "skipped"
+                });
+                continue;
+              }
+            }
+            const decision = await options.decide?.(item) ?? (item.run.state === "queued" ? { action: "resume" } : { action: "skip" });
+            if (decision.action === "skip") {
+              outcomes.push({
+                conversationId: item.conversationId,
+                runId: item.run.id,
+                outcome: "skipped"
+              });
+              continue;
+            }
+            if (decision.action === "abandon") {
+              const abandoned = await config.store.recoverRun({
+                conversationId: item.conversationId,
+                runId: item.run.id,
+                expectedRevision: item.run.revision,
+                action: "abandon"
+              });
+              if (abandoned.outcome !== "applied") {
+                throw new AgentRuntimeConflictError("recovery abandon");
+              }
+              outcomes.push({
+                conversationId: item.conversationId,
+                runId: item.run.id,
+                outcome: "abandoned"
+              });
+              continue;
+            }
+            if (decision.action === "requeue") {
+              const requeued = await config.store.recoverRun({
+                conversationId: item.conversationId,
+                runId: item.run.id,
+                expectedRevision: item.run.revision,
+                action: "requeue",
+                replaySafe: true
+              });
+              if (requeued.outcome !== "applied") {
+                throw new AgentRuntimeConflictError("recovery requeue");
+              }
+            }
+            const context = await options.resolveContext(item);
+            const resumed = resume({
+              conversationId: item.conversationId,
+              runId: item.run.id,
+              context
+            });
+            resumed.result.catch(() => {
+              return;
+            });
+            await resumed.accepted;
+            outcomes.push({
+              conversationId: item.conversationId,
+              runId: item.run.id,
+              outcome: decision.action === "requeue" ? "requeued" : "resumed"
+            });
+          } catch (error) {
+            outcomes.push({
+              conversationId: item.conversationId,
+              runId: item.run.id,
+              outcome: "failed",
+              error
+            });
+          }
+        }
+        cursor = page.nextCursor;
+        if (!cursor || page.items.length === 0)
+          break;
+      }
+      return outcomes;
+    },
     stop: (conversationKey, reason) => coordinator.stop(conversationKey, reason),
     close: (options) => coordinator.close(options)
   };
 }
 // src/agent-runtime/store.ts
-import { z as z7 } from "zod";
-var AgentStoreConflictSchema = z7.object({
-  outcome: z7.literal("conflict"),
+import { z as z6 } from "zod";
+var AgentStoreConflictSchema = z6.object({
+  outcome: z6.literal("conflict"),
   actualVersion: AgentRecordVersionSchema
 });
-var AgentStoreNotFoundSchema = z7.object({
-  outcome: z7.literal("not_found")
-});
-var AgentStoreAppliedSchema = z7.object({
-  outcome: z7.literal("applied"),
+var AgentStoreNotFoundSchema = z6.object({ outcome: z6.literal("not_found") });
+var AgentStoreAppliedSchema = z6.object({
+  outcome: z6.literal("applied"),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreDuplicateSchema = z7.object({
-  outcome: z7.literal("duplicate"),
+var AgentStoreDuplicateSchema = z6.object({
+  outcome: z6.literal("duplicate"),
+  input: AgentMessageSchema,
+  inputMessageId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema,
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreMutationResultSchema = z7.discriminatedUnion("outcome", [
+var AgentStoreMutationResultSchema = z6.discriminatedUnion("outcome", [
   AgentStoreAppliedSchema,
   AgentStoreDuplicateSchema,
   AgentStoreConflictSchema,
   AgentStoreNotFoundSchema
 ]);
-var AcceptInputAndAssignRunSchema = z7.object({
-  idempotencyKey: z7.string().min(1),
+var AcceptInputAndAssignRunSchema = z6.object({
+  idempotencyKey: z6.string().min(1),
   expectedVersion: AgentRecordVersionSchema.optional(),
   input: AgentMessageSchema,
   run: AgentRunSchema,
   coalesceIntoRunId: AgentRecordIdSchema.optional()
 });
-var AcquireAgentRunSchema = z7.object({
+var AcquireAgentRunSchema = z6.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z7.string().min(1)
+  ownerId: z6.string().min(1)
 });
-var CheckpointRunAssistantSchema = z7.object({
+var CheckpointRunAssistantSchema = z6.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z7.string().min(1),
+  ownerId: z6.string().min(1),
   assistant: AgentMessageSchema
 });
-var CommitRunTerminalSchema = z7.object({
+var CommitRunTerminalSchema = z6.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z7.string().min(1),
+  ownerId: z6.string().min(1),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z7.string().min(1).optional()
+  policyName: z6.string().min(1).optional()
 });
-var RequestRunInterruptSchema = z7.object({
+var RequestRunInterruptSchema = z6.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema
 });
-var RecoverAgentRunSchema = z7.object({
+var RecoverAgentRunSchema = z6.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  action: z7.enum(["requeue", "abandon"]),
-  replaySafe: z7.boolean().optional()
+  action: z6.enum(["requeue", "abandon"]),
+  replaySafe: z6.boolean().optional()
 });
-var ReplaceCompactedRangeSchema = z7.object({
+var ReplaceCompactedRangeSchema = z6.object({
   conversationId: AgentRecordIdSchema,
   expectedVersion: AgentRecordVersionSchema,
-  replacedMessageIds: z7.array(AgentRecordIdSchema).min(1),
+  replacedMessageIds: z6.array(AgentRecordIdSchema).min(1),
   summary: AgentMessageSchema
 });
-function emptySnapshot(conversationId) {
-  return AgentSnapshotSchema.parse({
+// src/agent-runtime/store-driver.ts
+import { z as z7 } from "zod";
+var AgentAdmissionIdentitySchema = z7.object({
+  idempotencyKey: z7.string().min(1),
+  inputMessageId: AgentRecordIdSchema,
+  runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema
+});
+var AgentStoredStateSchema = z7.object({
+  schemaVersion: z7.literal(1),
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema,
+  runs: z7.array(AgentRunSchema),
+  admissions: z7.array(AgentAdmissionIdentitySchema)
+});
+var AgentHistoryMutationSchema = z7.discriminatedUnion("type", [
+  z7.object({ type: z7.literal("admit"), input: AgentMessageSchema }),
+  z7.object({
+    type: z7.literal("upsert-assistant"),
+    message: AgentMessageSchema
+  }),
+  z7.object({
+    type: z7.literal("replace-compacted-range"),
+    replacedMessageIds: z7.array(AgentRecordIdSchema).min(1),
+    summary: AgentMessageSchema
+  })
+]);
+var AgentRecoverableDescriptorSchema = z7.object({
+  conversationId: AgentRecordIdSchema,
+  run: AgentRunSchema
+});
+var AgentRecoverablePageSchema = z7.object({
+  items: z7.array(AgentRecoverableDescriptorSchema),
+  nextCursor: z7.string().min(1).optional()
+});
+var AgentRecoverableScanInputSchema = z7.object({
+  cursor: z7.string().min(1).optional(),
+  limit: z7.number().int().min(1).max(1000)
+});
+function emptyState(conversationId) {
+  return AgentStoredStateSchema.parse({
     schemaVersion: 1,
     conversationId,
     version: 0,
-    messages: [],
-    runs: []
+    runs: [],
+    admissions: []
   });
 }
-function cloneSnapshot(snapshot) {
-  return AgentSnapshotSchema.parse(structuredClone(snapshot));
+function snapshotOf(state, messages) {
+  validateAggregate(state, messages);
+  return AgentSnapshotSchema.parse({
+    schemaVersion: 1,
+    conversationId: state.conversationId,
+    version: state.version,
+    messages,
+    runs: state.runs
+  });
+}
+function validateAggregate(state, messages) {
+  const runIds = new Set;
+  const assistantIds = new Set;
+  const messageIds = new Set;
+  const idempotencyKeys = new Set;
+  const admittedInputIds = new Set;
+  for (const run of state.runs) {
+    if (run.conversationId !== state.conversationId || runIds.has(run.id) || assistantIds.has(run.assistantMessageId)) {
+      throw new TypeError("Stored agent state contains inconsistent run identities");
+    }
+    runIds.add(run.id);
+    assistantIds.add(run.assistantMessageId);
+  }
+  for (const message of messages) {
+    if (message.conversationId !== state.conversationId || messageIds.has(message.id)) {
+      throw new TypeError("Stored agent history contains inconsistent message identities");
+    }
+    messageIds.add(message.id);
+    if (assistantIds.has(message.id) && message.runId === undefined) {
+      throw new TypeError("Stored history occupies a reserved assistant identity");
+    }
+    if (message.runId !== undefined) {
+      const run = state.runs.find((candidate) => candidate.id === message.runId);
+      if (!run || message.role !== "assistant" || run.assistantMessageId !== message.id) {
+        throw new TypeError("Stored assistant history does not match its reserved run identity");
+      }
+    }
+  }
+  for (const admission of state.admissions) {
+    const run = state.runs.find((candidate) => candidate.id === admission.runId);
+    if (idempotencyKeys.has(admission.idempotencyKey) || admittedInputIds.has(admission.inputMessageId) || !run || run.assistantMessageId !== admission.assistantMessageId || !run.inputMessageIds.includes(admission.inputMessageId)) {
+      throw new TypeError("Stored admission identity is inconsistent with its assigned run");
+    }
+    idempotencyKeys.add(admission.idempotencyKey);
+    admittedInputIds.add(admission.inputMessageId);
+  }
+}
+function recoverableDescriptors(state) {
+  return state.runs.filter((run) => ["queued", "running", "interrupt_requested"].includes(run.state)).map((run) => ({ conversationId: state.conversationId, run }));
+}
+var RecoverableCursorSchema = z7.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+function recoverableCursor(input) {
+  return JSON.stringify([input.conversationId, input.run.id]);
+}
+function parseRecoverableCursor(cursor) {
+  return RecoverableCursorSchema.parse(JSON.parse(cursor));
 }
 function replaceRun(runs, next) {
   return runs.map((run) => run.id === next.id ? next : run);
 }
 function replaceMessage(messages, next) {
-  const exists = messages.some((message) => message.id === next.id);
-  if (!exists)
-    return [...messages, next];
-  return messages.map((message) => message.id === next.id ? next : message);
+  return messages.some((message) => message.id === next.id) ? messages.map((message) => message.id === next.id ? next : message) : [...messages, next];
+}
+function conflict(actualVersion) {
+  return { outcome: "conflict", actualVersion };
 }
 function terminalState(reason) {
   if (reason === "success" || reason === "policy_stop")
@@ -1715,217 +1904,426 @@ function terminalMessageStatus(reason) {
   }
   return "failed";
 }
-function createMemoryAgentRuntimeStore() {
-  const conversations = new Map;
-  const get = (conversationId) => {
-    const existing = conversations.get(conversationId);
-    if (existing)
-      return existing;
-    const created = { snapshot: emptySnapshot(conversationId), idempotency: new Map };
-    conversations.set(conversationId, created);
-    return created;
-  };
-  const conflict = (actualVersion) => ({
-    outcome: "conflict",
-    actualVersion
-  });
-  const apply = (entry, snapshot) => {
-    entry.snapshot = AgentSnapshotSchema.parse(snapshot);
-    return { outcome: "applied", snapshot: cloneSnapshot(entry.snapshot) };
-  };
+function applied(current, admissions, input, historyMutation) {
   return {
-    async loadSnapshot(conversationId) {
-      return cloneSnapshot(get(conversationId).snapshot);
-    },
-    async acceptInputAndAssignRun(rawInput) {
-      const input = AcceptInputAndAssignRunSchema.parse(rawInput);
-      const entry = get(input.input.conversationId);
-      const duplicateRunId = entry.idempotency.get(input.idempotencyKey);
-      if (duplicateRunId !== undefined) {
-        return {
-          outcome: "duplicate",
-          runId: duplicateRunId,
-          snapshot: cloneSnapshot(entry.snapshot)
-        };
-      }
-      if (input.expectedVersion !== undefined && input.expectedVersion !== entry.snapshot.version) {
-        return conflict(entry.snapshot.version);
-      }
-      const coalescedRun = input.coalesceIntoRunId ? entry.snapshot.runs.find((candidate) => candidate.id === input.coalesceIntoRunId) : undefined;
-      if (input.coalesceIntoRunId !== undefined && (!coalescedRun || coalescedRun.conversationId !== input.input.conversationId || coalescedRun.state !== "queued" || coalescedRun.ownerId !== undefined || coalescedRun.terminalReason !== undefined)) {
-        return coalescedRun ? conflict(coalescedRun.revision) : { outcome: "not_found" };
-      }
-      if (input.run.conversationId !== input.input.conversationId || input.run.inputMessageIds.length !== 1 || input.run.inputMessageIds[0] !== input.input.id || input.run.state !== "queued" || input.run.revision !== 0 || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" || input.input.status !== "committed" || input.input.runId !== undefined || entry.snapshot.messages.some((message) => message.id === input.input.id) || !coalescedRun && (input.run.assistantMessageId === input.input.id || entry.snapshot.runs.some((candidate) => candidate.id === input.run.id) || entry.snapshot.runs.some((candidate) => candidate.assistantMessageId === input.run.assistantMessageId) || entry.snapshot.messages.some((message) => message.id === input.run.assistantMessageId))) {
-        throw new TypeError("Input and queued run do not form one valid assignment");
+    outcome: "applied",
+    snapshot: AgentSnapshotSchema.parse({
+      ...current,
+      version: current.version + 1,
+      runs: input.runs ?? current.runs,
+      messages: input.messages ?? current.messages
+    }),
+    admissions,
+    ...historyMutation && { historyMutation }
+  };
+}
+function reduceStore(current, currentAdmissions, operation, duplicateInput) {
+  if (operation.type === "accept") {
+    const input = operation.input;
+    const duplicate = currentAdmissions.find((candidate) => candidate.idempotencyKey === input.idempotencyKey);
+    if (duplicate) {
+      if (!duplicateInput) {
+        throw new Error("Duplicate admission input is unavailable from canonical history");
       }
-      const assignedRun = coalescedRun ? AgentRunSchema.parse({
-        ...coalescedRun,
-        inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
-        revision: coalescedRun.revision + 1,
+      return {
+        outcome: "duplicate",
+        input: duplicateInput,
+        inputMessageId: duplicate.inputMessageId,
+        runId: duplicate.runId,
+        assistantMessageId: duplicate.assistantMessageId,
+        snapshot: current
+      };
+    }
+    if (input.expectedVersion !== undefined && input.expectedVersion !== current.version) {
+      return conflict(current.version);
+    }
+    const coalescedRun = input.coalesceIntoRunId ? current.runs.find((candidate) => candidate.id === input.coalesceIntoRunId) : undefined;
+    if (input.coalesceIntoRunId !== undefined && (!coalescedRun || coalescedRun.conversationId !== input.input.conversationId || coalescedRun.state !== "queued" || coalescedRun.ownerId !== undefined || coalescedRun.terminalReason !== undefined)) {
+      return coalescedRun ? conflict(coalescedRun.revision) : { outcome: "not_found" };
+    }
+    if (input.run.conversationId !== input.input.conversationId || input.run.inputMessageIds.length !== 1 || input.run.inputMessageIds[0] !== input.input.id || input.run.state !== "queued" || input.run.revision !== 0 || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" || input.input.status !== "committed" || input.input.runId !== undefined || current.messages.some((message) => message.id === input.input.id) || coalescedRun !== undefined && input.input.id === coalescedRun.assistantMessageId || !coalescedRun && (input.run.assistantMessageId === input.input.id || current.runs.some((candidate) => candidate.id === input.run.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.run.assistantMessageId) || current.messages.some((message) => message.id === input.run.assistantMessageId))) {
+      throw new TypeError("Input and queued run do not form one valid assignment");
+    }
+    const assignedRun = coalescedRun ? AgentRunSchema.parse({
+      ...coalescedRun,
+      inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
+      revision: coalescedRun.revision + 1,
+      updatedAt: new Date().toISOString()
+    }) : input.run;
+    const admission = AgentAdmissionIdentitySchema.parse({
+      idempotencyKey: input.idempotencyKey,
+      inputMessageId: input.input.id,
+      runId: assignedRun.id,
+      assistantMessageId: assignedRun.assistantMessageId
+    });
+    return applied(current, [...currentAdmissions, admission], {
+      messages: [...current.messages, input.input],
+      runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
+    }, { type: "admit", input: input.input });
+  }
+  const conversationId = operation.input.conversationId;
+  const run = operation.type === "compact" ? undefined : current.runs.find((candidate) => candidate.id === operation.input.runId);
+  if (operation.type !== "compact" && !run)
+    return { outcome: "not_found" };
+  if (operation.type === "acquire" && run) {
+    const runPosition = current.runs.findIndex((candidate) => candidate.id === run.id);
+    const acquisitionBlocked = current.runs.some((candidate, index) => candidate.id !== run.id && (candidate.state === "running" || candidate.state === "interrupt_requested" || index < runPosition && candidate.state === "queued"));
+    if (run.revision !== operation.input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
+      return conflict(run.revision);
+    }
+    const next = AgentRunSchema.parse({
+      ...run,
+      state: "running",
+      ownerId: operation.input.ownerId,
+      revision: run.revision + 1,
+      updatedAt: new Date().toISOString()
+    });
+    return applied(current, currentAdmissions, {
+      runs: replaceRun(current.runs, next)
+    });
+  }
+  if (operation.type === "checkpoint" && run) {
+    const input = operation.input;
+    if (run.revision !== input.expectedRevision || run.state !== "running" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== "streaming") {
+      return conflict(run.revision);
+    }
+    const next = AgentRunSchema.parse({
+      ...run,
+      revision: run.revision + 1,
+      updatedAt: new Date().toISOString()
+    });
+    return applied(current, currentAdmissions, {
+      runs: replaceRun(current.runs, next),
+      messages: replaceMessage(current.messages, input.assistant)
+    }, { type: "upsert-assistant", message: input.assistant });
+  }
+  if (operation.type === "interrupt" && run) {
+    if (run.revision !== operation.input.expectedRevision || run.state !== "running") {
+      return conflict(run.revision);
+    }
+    const next = AgentRunSchema.parse({
+      ...run,
+      state: "interrupt_requested",
+      revision: run.revision + 1,
+      updatedAt: new Date().toISOString()
+    });
+    return applied(current, currentAdmissions, {
+      runs: replaceRun(current.runs, next)
+    });
+  }
+  if (operation.type === "recover" && run) {
+    const input = operation.input;
+    if (run.revision !== input.expectedRevision || !["queued", "running", "interrupt_requested"].includes(run.state)) {
+      return conflict(run.revision);
+    }
+    if (input.action === "requeue" && run.state !== "queued" && input.replaySafe !== true) {
+      throw new TypeError("Recovering an acquired run requires explicit replaySafe evidence");
+    }
+    const next = AgentRunSchema.parse({
+      schemaVersion: 1,
+      id: run.id,
+      conversationId: run.conversationId,
+      inputMessageIds: run.inputMessageIds,
+      assistantMessageId: run.assistantMessageId,
+      state: input.action === "requeue" ? "queued" : "abandoned",
+      revision: run.revision + 1,
+      ...input.action === "abandon" && { terminalReason: "abandoned" },
+      createdAt: run.createdAt,
+      updatedAt: new Date().toISOString()
+    });
+    if (input.action === "abandon") {
+      const existingAssistant = current.messages.find((message) => message.id === run.assistantMessageId);
+      const assistant = AgentMessageSchema.parse({
+        ...existingAssistant ?? {
+          schemaVersion: 1,
+          id: run.assistantMessageId,
+          conversationId: run.conversationId,
+          runId: run.id,
+          role: "assistant",
+          parts: [],
+          createdAt: run.createdAt
+        },
+        status: "failed",
         updatedAt: new Date().toISOString()
-      }) : input.run;
-      const next = AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        messages: [...entry.snapshot.messages, input.input],
-        runs: coalescedRun ? replaceRun(entry.snapshot.runs, assignedRun) : [...entry.snapshot.runs, assignedRun]
       });
-      entry.idempotency.set(input.idempotencyKey, assignedRun.id);
-      return apply(entry, next);
+      return applied(current, currentAdmissions, {
+        runs: replaceRun(current.runs, next),
+        messages: replaceMessage(current.messages, assistant)
+      }, { type: "upsert-assistant", message: assistant });
+    }
+    return applied(current, currentAdmissions, {
+      runs: replaceRun(current.runs, next)
+    });
+  }
+  if (operation.type === "terminal" && run) {
+    const input = operation.input;
+    if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== terminalMessageStatus(input.reason)) {
+      return conflict(run.revision);
+    }
+    const next = AgentRunSchema.parse({
+      ...run,
+      state: terminalState(input.reason),
+      terminalReason: input.reason,
+      ...input.policyName && { terminalPolicyName: input.policyName },
+      revision: run.revision + 1,
+      updatedAt: new Date().toISOString()
+    });
+    return applied(current, currentAdmissions, {
+      runs: replaceRun(current.runs, next),
+      messages: replaceMessage(current.messages, input.assistant)
+    }, { type: "upsert-assistant", message: input.assistant });
+  }
+  if (operation.type === "compact") {
+    const input = operation.input;
+    if (current.conversationId !== conversationId)
+      return { outcome: "not_found" };
+    if (current.version !== input.expectedVersion)
+      return conflict(current.version);
+    const replaced = new Set(input.replacedMessageIds);
+    if (!input.replacedMessageIds.every((id) => current.messages.some((m) => m.id === id))) {
+      return { outcome: "not_found" };
+    }
+    const positions = current.messages.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
+    const first = positions[0];
+    if (first === undefined || positions.some((position, offset) => position !== first + offset) || input.summary.conversationId !== input.conversationId || input.summary.runId !== undefined || input.summary.role !== "summary" || input.summary.status !== "committed" || current.messages.some((message) => message.id === input.summary.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.summary.id)) {
+      throw new TypeError("Compaction replacement must be one valid contiguous history range");
+    }
+    const messages = [
+      ...current.messages.slice(0, first),
+      input.summary,
+      ...current.messages.slice(first + positions.length)
+    ];
+    return applied(current, currentAdmissions, { messages }, {
+      type: "replace-compacted-range",
+      replacedMessageIds: input.replacedMessageIds,
+      summary: input.summary
+    });
+  }
+  return { outcome: "not_found" };
+}
+function operationConversationId(operation) {
+  return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
+}
+function createAgentRuntimeStore(driver) {
+  const loadSnapshot = (conversationId) => driver.transaction(async (transaction) => {
+    const [stored, messages] = await Promise.all([
+      driver.state.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId)
+    ]);
+    return snapshotOf(stored ?? emptyState(conversationId), messages);
+  });
+  const mutate = (operation) => driver.transaction(async (transaction) => {
+    const conversationId = operationConversationId(operation);
+    const [stored, messages] = await Promise.all([
+      driver.state.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId)
+    ]);
+    const state = AgentStoredStateSchema.parse(stored ?? emptyState(conversationId));
+    const current = snapshotOf(state, messages);
+    const duplicateIdentity = operation.type === "accept" ? state.admissions.find((candidate) => candidate.idempotencyKey === operation.input.idempotencyKey) : undefined;
+    const duplicateInput = duplicateIdentity ? await driver.history.loadById(transaction, {
+      conversationId,
+      messageId: duplicateIdentity.inputMessageId
+    }) : undefined;
+    if (duplicateIdentity && duplicateInput && (duplicateInput.id !== duplicateIdentity.inputMessageId || duplicateInput.conversationId !== conversationId || duplicateInput.role !== "user" || duplicateInput.status !== "committed" || duplicateInput.runId !== undefined)) {
+      throw new TypeError("Canonical duplicate input does not match its admission identity");
+    }
+    const reduced = reduceStore(current, state.admissions, operation, duplicateInput);
+    if (reduced.outcome !== "applied")
+      return reduced;
+    const nextState = AgentStoredStateSchema.parse({
+      schemaVersion: 1,
+      conversationId,
+      version: reduced.snapshot.version,
+      runs: reduced.snapshot.runs,
+      admissions: reduced.admissions
+    });
+    const outcome = await driver.state.compareAndSwap(transaction, {
+      conversationId,
+      expectedVersion: current.version,
+      next: nextState,
+      recoverable: recoverableDescriptors(nextState)
+    });
+    if (outcome.outcome === "conflict")
+      return conflict(outcome.actualVersion);
+    if (reduced.historyMutation) {
+      await driver.history.apply(transaction, reduced.historyMutation);
+    }
+    return { outcome: "applied", snapshot: reduced.snapshot };
+  });
+  return {
+    loadSnapshot,
+    acceptInputAndAssignRun: (input) => mutate({
+      type: "accept",
+      input: AcceptInputAndAssignRunSchema.parse(input)
+    }),
+    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema.parse(input) }),
+    checkpointRunAssistant: (input) => mutate({
+      type: "checkpoint",
+      input: CheckpointRunAssistantSchema.parse(input)
+    }),
+    requestRunInterrupt: (input) => mutate({
+      type: "interrupt",
+      input: RequestRunInterruptSchema.parse(input)
+    }),
+    recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema.parse(input) }),
+    commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema.parse(input) }),
+    replaceCompactedRange: (input) => mutate({
+      type: "compact",
+      input: ReplaceCompactedRangeSchema.parse(input)
+    }),
+    async scanRecoverable() {
+      const snapshots = [];
+      const seenConversationIds = new Set;
+      let cursor;
+      do {
+        const page = AgentRecoverablePageSchema.parse(await driver.scanRecoverable({
+          ...cursor && { cursor },
+          limit: 100
+        }));
+        const conversationIds = [
+          ...new Set(page.items.map((item) => item.conversationId))
+        ].filter((conversationId) => !seenConversationIds.has(conversationId));
+        for (const conversationId of conversationIds)
+          seenConversationIds.add(conversationId);
+        snapshots.push(...await Promise.all(conversationIds.map(loadSnapshot)));
+        cursor = page.nextCursor;
+      } while (cursor !== undefined);
+      return snapshots;
     },
-    async acquireRun(rawInput) {
-      const input = AcquireAgentRunSchema.parse(rawInput);
-      const entry = get(input.conversationId);
-      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
-      if (!run)
-        return { outcome: "not_found" };
-      if (run.revision !== input.expectedRevision || run.state !== "queued") {
-        return conflict(run.revision);
-      }
-      const nextRun = AgentRunSchema.parse({
-        ...run,
-        state: "running",
-        ownerId: input.ownerId,
-        revision: run.revision + 1,
-        updatedAt: new Date().toISOString()
+    async scanRecoverablePage(input) {
+      const parsed = AgentRecoverableScanInputSchema.parse(input);
+      return AgentRecoverablePageSchema.parse(await driver.scanRecoverable(parsed));
+    }
+  };
+}
+function cloneStateMap(source) {
+  return new Map([...source].map(([key, value]) => [
+    key,
+    AgentStoredStateSchema.parse(structuredClone(value))
+  ]));
+}
+function cloneHistoryMap(source) {
+  return new Map([...source].map(([key, value]) => [
+    key,
+    value.map((message) => AgentMessageSchema.parse(structuredClone(message)))
+  ]));
+}
+function createMemoryAgentRuntimeStore() {
+  let states = new Map;
+  let histories = new Map;
+  let archivedMessages = new Map;
+  let transactionTail = Promise.resolve();
+  const driver = {
+    async transaction(work) {
+      const previous = transactionTail;
+      const release = Promise.withResolvers();
+      transactionTail = previous.catch(() => {
+        return;
+      }).then(() => release.promise);
+      await previous.catch(() => {
+        return;
       });
-      return apply(entry, AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        runs: replaceRun(entry.snapshot.runs, nextRun)
-      }));
-    },
-    async checkpointRunAssistant(rawInput) {
-      const input = CheckpointRunAssistantSchema.parse(rawInput);
-      const entry = get(input.conversationId);
-      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
-      if (!run)
-        return { outcome: "not_found" };
-      if (run.revision !== input.expectedRevision || run.state !== "running" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== "streaming") {
-        return conflict(run.revision);
+      const transaction = {
+        states: cloneStateMap(states),
+        histories: cloneHistoryMap(histories),
+        archivedMessages: new Map([...archivedMessages].map(([conversationId, messages]) => [
+          conversationId,
+          new Map([...messages].map(([messageId, message]) => [
+            messageId,
+            AgentMessageSchema.parse(structuredClone(message))
+          ]))
+        ]))
+      };
+      try {
+        const result = await work(transaction);
+        states = transaction.states;
+        histories = transaction.histories;
+        archivedMessages = transaction.archivedMessages;
+        return result;
+      } finally {
+        release.resolve();
       }
-      const nextRun = AgentRunSchema.parse({
-        ...run,
-        revision: run.revision + 1,
-        updatedAt: new Date().toISOString()
-      });
-      return apply(entry, AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        messages: replaceMessage(entry.snapshot.messages, input.assistant),
-        runs: replaceRun(entry.snapshot.runs, nextRun)
-      }));
     },
-    async requestRunInterrupt(rawInput) {
-      const input = RequestRunInterruptSchema.parse(rawInput);
-      const entry = get(input.conversationId);
-      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
-      if (!run)
-        return { outcome: "not_found" };
-      if (run.revision !== input.expectedRevision || run.state !== "running") {
-        return conflict(run.revision);
+    state: {
+      async load(transaction, conversationId) {
+        const state = transaction.states.get(conversationId);
+        return state ? AgentStoredStateSchema.parse(structuredClone(state)) : undefined;
+      },
+      async compareAndSwap(transaction, input) {
+        const current = transaction.states.get(input.conversationId);
+        const actualVersion = current?.version ?? 0;
+        if (actualVersion !== input.expectedVersion) {
+          return { outcome: "conflict", actualVersion };
+        }
+        transaction.states.set(input.conversationId, AgentStoredStateSchema.parse(structuredClone(input.next)));
+        return { outcome: "applied" };
       }
-      const nextRun = AgentRunSchema.parse({
-        ...run,
-        state: "interrupt_requested",
-        revision: run.revision + 1,
-        updatedAt: new Date().toISOString()
-      });
-      return apply(entry, AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        runs: replaceRun(entry.snapshot.runs, nextRun)
-      }));
     },
-    async recoverRun(rawInput) {
-      const input = RecoverAgentRunSchema.parse(rawInput);
-      const entry = get(input.conversationId);
-      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
-      if (!run)
-        return { outcome: "not_found" };
-      if (run.revision !== input.expectedRevision || !["queued", "running", "interrupt_requested"].includes(run.state)) {
-        return conflict(run.revision);
-      }
-      if (input.action === "requeue" && run.state !== "queued" && input.replaySafe !== true) {
-        throw new TypeError("Recovering an acquired run requires explicit replaySafe evidence");
+    history: {
+      async load(transaction, conversationId) {
+        return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema.parse(structuredClone(message)));
+      },
+      async loadById(transaction, input) {
+        const active = (transaction.histories.get(input.conversationId) ?? []).find((message2) => message2.id === input.messageId);
+        const message = active ?? transaction.archivedMessages.get(input.conversationId)?.get(input.messageId);
+        return message ? AgentMessageSchema.parse(structuredClone(message)) : undefined;
+      },
+      async apply(transaction, rawMutation) {
+        const mutation = AgentHistoryMutationSchema.parse(rawMutation);
+        const conversationId = mutation.type === "admit" ? mutation.input.conversationId : mutation.type === "upsert-assistant" ? mutation.message.conversationId : mutation.summary.conversationId;
+        const current = transaction.histories.get(conversationId) ?? [];
+        if (mutation.type === "admit") {
+          transaction.histories.set(conversationId, [...current, mutation.input]);
+          return;
+        }
+        if (mutation.type === "upsert-assistant") {
+          transaction.histories.set(conversationId, replaceMessage(current, mutation.message));
+          return;
+        }
+        const replaced = new Set(mutation.replacedMessageIds);
+        const positions = current.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
+        const first = positions[0];
+        if (first === undefined)
+          throw new Error("Compaction history range disappeared");
+        const archive = transaction.archivedMessages.get(conversationId) ?? new Map;
+        for (const message of current.filter((candidate) => replaced.has(candidate.id))) {
+          archive.set(message.id, AgentMessageSchema.parse(structuredClone(message)));
+        }
+        transaction.archivedMessages.set(conversationId, archive);
+        transaction.histories.set(conversationId, [
+          ...current.slice(0, first),
+          mutation.summary,
+          ...current.slice(first + positions.length)
+        ]);
       }
-      const nextRun = AgentRunSchema.parse({
-        schemaVersion: 1,
-        id: run.id,
-        conversationId: run.conversationId,
-        inputMessageIds: run.inputMessageIds,
-        assistantMessageId: run.assistantMessageId,
-        state: input.action === "requeue" ? "queued" : "abandoned",
-        revision: run.revision + 1,
-        ...input.action === "abandon" && { terminalReason: "abandoned" },
-        createdAt: run.createdAt,
-        updatedAt: new Date().toISOString()
-      });
-      return apply(entry, AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        runs: replaceRun(entry.snapshot.runs, nextRun)
-      }));
     },
-    async commitRunTerminal(rawInput) {
-      const input = CommitRunTerminalSchema.parse(rawInput);
-      const entry = get(input.conversationId);
-      const run = entry.snapshot.runs.find((candidate) => candidate.id === input.runId);
-      if (!run)
-        return { outcome: "not_found" };
-      if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== terminalMessageStatus(input.reason)) {
-        return conflict(run.revision);
-      }
-      const nextRun = AgentRunSchema.parse({
-        ...run,
-        state: terminalState(input.reason),
-        terminalReason: input.reason,
-        ...input.policyName && { terminalPolicyName: input.policyName },
-        revision: run.revision + 1,
-        updatedAt: new Date().toISOString()
+    async scanRecoverable(input) {
+      const descriptors = [...states.values()].flatMap((state) => state.runs.filter((run) => ["queued", "running", "interrupt_requested"].includes(run.state)).map((run) => ({ conversationId: state.conversationId, run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
+      const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
+      const start = cursorTuple ? descriptors.findIndex((item) => item.conversationId === cursorTuple[0] && item.run.id === cursorTuple[1]) + 1 : 0;
+      const items = descriptors.slice(start, start + input.limit);
+      const last = items.at(-1);
+      const hasMore = start + items.length < descriptors.length;
+      return AgentRecoverablePageSchema.parse({
+        items,
+        ...hasMore && last && { nextCursor: recoverableCursor(last) }
       });
-      return apply(entry, AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        messages: replaceMessage(entry.snapshot.messages, input.assistant),
-        runs: replaceRun(entry.snapshot.runs, nextRun)
-      }));
-    },
-    async replaceCompactedRange(rawInput) {
-      const input = ReplaceCompactedRangeSchema.parse(rawInput);
-      const entry = get(input.conversationId);
-      if (entry.snapshot.version !== input.expectedVersion) {
-        return conflict(entry.snapshot.version);
-      }
-      const replaced = new Set(input.replacedMessageIds);
-      if (!input.replacedMessageIds.every((id) => entry.snapshot.messages.some((m) => m.id === id))) {
-        return { outcome: "not_found" };
-      }
-      const positions = entry.snapshot.messages.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
-      const first = positions[0];
-      if (first === undefined || positions.some((position, offset) => position !== first + offset) || input.summary.conversationId !== input.conversationId || input.summary.runId !== undefined || input.summary.role !== "summary" || input.summary.status !== "committed") {
-        throw new TypeError("Compaction replacement must be one valid contiguous history range");
-      }
-      const before = entry.snapshot.messages.slice(0, first);
-      const after = entry.snapshot.messages.slice(first + positions.length);
-      return apply(entry, AgentSnapshotSchema.parse({
-        ...entry.snapshot,
-        version: entry.snapshot.version + 1,
-        messages: [...before, input.summary, ...after]
-      }));
-    },
-    async scanRecoverable() {
-      return [...conversations.values()].filter((entry) => entry.snapshot.runs.some((run) => ["queued", "running", "interrupt_requested"].includes(run.state))).map((entry) => cloneSnapshot(entry.snapshot));
     }
   };
+  return createAgentRuntimeStore(driver);
 }
 export {
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
+  AgentAdmissionEventSchema,
+  AgentAdmissionIdentitySchema,
+  AgentAssistantPlaceholderSchema,
   AgentCheckpointEventSchema,
   AgentControlPartSchema,
   AgentCostValueSchema,
   AgentFilePartSchema,
+  AgentHistoryMutationSchema,
   AgentJsonObjectSchema,
   AgentMessagePartSchema,
   AgentMessageRoleSchema,
@@ -1935,10 +2333,16 @@ export {
   AgentModelDescriptorSchema,
   AgentOpaquePartSchema,
   AgentProviderEnvelopeSchema,
+  AgentReasoningDeltaEventSchema,
+  AgentReasoningEndEventSchema,
   AgentReasoningPartSchema,
+  AgentReasoningStartEventSchema,
   AgentRecordIdSchema,
   AgentRecordVersionSchema,
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
   AgentRunEventSchema,
+  AgentRunMetricsSchema,
   AgentRunSchema,
   AgentRunStateEventSchema,
   AgentRunStateSchema,
@@ -1950,6 +2354,7 @@ export {
   AgentStoreDuplicateSchema,
   AgentStoreMutationResultSchema,
   AgentStoreNotFoundSchema,
+  AgentStoredStateSchema,
   AgentTerminalEventSchema,
   AgentTerminalReasonSchema,
   AgentTextPartSchema,
@@ -1969,6 +2374,7 @@ export {
   composeAgentPrompt,
   createAgentObservability,
   createAgentRuntime,
+  createAgentRuntimeStore,
   createAgentSessionCoordinator,
   createAgentToolFenceLifecycle,
   createMemoryAgentRuntimeStore,