stitchkit 0.56.5 → 0.58.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-vtjgx3vv.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -58,54 +86,66 @@ function eligibleForCompaction(messages, keepRecentTurns) {
   const eligibleCount = Math.max(0, completeTurns.length - keepRecentTurns);
   return completeTurns.slice(0, eligibleCount).flatMap((turn) => turn.messages);
 }
-function mutationSnapshot(result, fallback) {
+function mutationSnapshot(result, fallback, attempts) {
   if (result.outcome === "applied" || result.outcome === "duplicate") {
-    return { outcome: "applied", snapshot: result.snapshot };
+    return { outcome: "applied", snapshot: result.snapshot, attempts };
   }
-  return { outcome: result.outcome, snapshot: fallback };
+  return { outcome: result.outcome, snapshot: fallback, attempts };
 }
 function structuredCompaction(config) {
   if (!Number.isSafeInteger(config.keepRecentTurns) || config.keepRecentTurns < 1) {
     throw new TypeError("keepRecentTurns must be a positive safe integer");
   }
+  const maxAttempts = config.maxAttempts ?? 1;
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new TypeError("maxAttempts must be a positive safe integer");
+  }
   return async (input) => {
-    const snapshot = await input.store.loadSnapshot(input.conversationId);
-    if (!await config.threshold(snapshot))
-      return { outcome: "not_needed", snapshot };
-    const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns);
-    if (eligibleMessages.length === 0)
-      return { outcome: "nothing_eligible", snapshot };
-    const leadingSummary = snapshot.messages[0]?.role === "summary" ? snapshot.messages[0] : undefined;
-    const previousSummary = input.previousSummary ?? (leadingSummary && config.readPreviousSummary ? config.schema.parse(config.readPreviousSummary(leadingSummary)) : undefined);
-    const rawSummary = await config.summarize({
-      conversationId: input.conversationId,
-      snapshot,
-      eligibleMessages,
-      ...previousSummary !== undefined && { previousSummary },
-      signal: input.signal
-    });
-    const summary = config.schema.parse(rawSummary);
-    if (input.signal.aborted)
-      throw input.signal.reason;
-    const summaryMessage = config.createSummaryMessage({
-      conversationId: input.conversationId,
-      summary,
-      compactedMessages: eligibleMessages
-    });
-    if (summaryMessage.role !== "summary" || summaryMessage.status !== "committed") {
-      throw new TypeError("Compaction summary must be one committed summary message");
+    let lastSnapshot = await input.store.loadSnapshot(input.conversationId);
+    for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+      const snapshot = attempt === 1 ? lastSnapshot : await input.store.loadSnapshot(input.conversationId);
+      lastSnapshot = snapshot;
+      if (!await config.threshold(snapshot)) {
+        return { outcome: "not_needed", snapshot, attempts: attempt };
+      }
+      const eligibleMessages = eligibleForCompaction(snapshot.messages, config.keepRecentTurns);
+      if (eligibleMessages.length === 0) {
+        return { outcome: "nothing_eligible", snapshot, attempts: attempt };
+      }
+      const leadingSummary = snapshot.messages[0]?.role === "summary" ? snapshot.messages[0] : undefined;
+      const previousSummary = leadingSummary && config.readPreviousSummary ? config.schema.parse(config.readPreviousSummary(leadingSummary)) : attempt === 1 ? input.previousSummary : undefined;
+      const rawSummary = await config.summarize({
+        conversationId: input.conversationId,
+        snapshot,
+        eligibleMessages,
+        ...previousSummary !== undefined && { previousSummary },
+        signal: input.signal
+      });
+      const summary = config.schema.parse(rawSummary);
+      if (input.signal.aborted)
+        throw input.signal.reason;
+      const summaryMessage = config.createSummaryMessage({
+        conversationId: input.conversationId,
+        summary,
+        compactedMessages: eligibleMessages
+      });
+      if (summaryMessage.role !== "summary" || summaryMessage.status !== "committed") {
+        throw new TypeError("Compaction summary must be one committed summary message");
+      }
+      const applied = await input.store.replaceCompactedRange({
+        conversationId: input.conversationId,
+        expectedVersion: snapshot.version,
+        replacedMessageIds: [
+          ...leadingSummary ? [leadingSummary.id] : [],
+          ...eligibleMessages.map((message) => message.id)
+        ],
+        summary: summaryMessage
+      });
+      if (applied.outcome !== "conflict" || attempt === maxAttempts) {
+        return mutationSnapshot(applied, snapshot, attempt);
+      }
     }
-    const previousSummaryMessage = previousSummary !== undefined && leadingSummary ? leadingSummary : undefined;
-    const applied = await input.store.replaceCompactedRange({
-      conversationId: input.conversationId,
-      expectedVersion: snapshot.version,
-      replacedMessageIds: [
-        ...previousSummaryMessage ? [previousSummaryMessage.id] : [],
-        ...eligibleMessages.map((message) => message.id)
-      ],
-      summary: summaryMessage
-    });
-    return mutationSnapshot(applied, snapshot);
+    return { outcome: "conflict", snapshot: lastSnapshot, attempts: maxAttempts };
   };
 }
 // src/agent-runtime/coordinator.ts
@@ -226,210 +266,78 @@ 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,
-  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
-});
-var AgentSnapshotSchema = z.object({
-  schemaVersion: z.literal(1),
+var AgentAdmissionEventSchema = z.object({
+  type: z.literal("admission"),
+  eventId: AgentRecordIdSchema,
   conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  messages: z.array(AgentMessageSchema),
-  runs: z.array(AgentRunSchema)
-});
-var AgentUsageValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
-});
-var AgentCostValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  currency: z.string().length(3).optional(),
-  provenance: z.enum(["provider-reported", "computed", "estimated", "unavailable"])
-});
-var AgentUsageSchema = z.object({
-  inputTokens: AgentUsageValueSchema,
-  outputTokens: AgentUsageValueSchema,
-  reasoningTokens: AgentUsageValueSchema.optional(),
-  cacheReadTokens: AgentUsageValueSchema.optional(),
-  cacheWriteTokens: AgentUsageValueSchema.optional(),
-  cost: AgentCostValueSchema.optional()
+  runId: AgentRecordIdSchema,
+  snapshotVersion: AgentRecordVersionSchema,
+  input: AgentMessageSchema,
+  run: AgentRunSchema,
+  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
+  emittedAt: AgentTimestampSchema
 });
-
-// src/agent-runtime/events.ts
-var EventIdentitySchema = z2.object({
+var EventIdentitySchema = z.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   emittedAt: AgentTimestampSchema
 });
 var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-delta"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  textDelta: z2.string()
+  type: z.literal("assistant-delta"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  textDelta: z.string()
 });
 var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
   provider: AgentProviderEnvelopeSchema.optional()
 });
 var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-start")
+  type: z.literal("reasoning-start")
 });
 var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-delta"),
-  textDelta: z2.string()
+  type: z.literal("reasoning-delta"),
+  textDelta: z.string()
 });
 var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-end")
+  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,
@@ -439,6 +347,63 @@ var AgentRuntimeEventSchema = z2.discriminatedUnion("type", [
   AgentToolStatusEventSchema,
   AgentTerminalEventSchema
 ]);
+var AgentRuntimeEventCursorSchema = z.object({
+  snapshotVersion: AgentRecordVersionSchema.optional(),
+  durableEventIds: z.array(AgentRecordIdSchema).optional(),
+  runtimeEpoch: z.string().min(1).optional(),
+  sequence: z.int().nonnegative().optional()
+});
+function isDurableEvent(event) {
+  return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
+}
+function advanceAgentRuntimeEventCursor(rawCursor, event) {
+  const cursor = AgentRuntimeEventCursorSchema.parse(rawCursor);
+  if (isDurableEvent(event)) {
+    const previous = cursor.snapshotVersion;
+    const durableEventIds = previous === event.snapshotVersion ? cursor.durableEventIds ?? [] : [];
+    if (previous !== undefined && event.snapshotVersion < previous || durableEventIds.includes(event.eventId)) {
+      return { status: "duplicate", cursor };
+    }
+    return {
+      status: previous !== undefined && event.snapshotVersion > previous + 1 ? "gap" : "accepted",
+      cursor: {
+        ...cursor,
+        snapshotVersion: event.snapshotVersion,
+        durableEventIds: [...durableEventIds, event.eventId]
+      }
+    };
+  }
+  const previousSequence = cursor.runtimeEpoch === event.runtimeEpoch ? cursor.sequence : undefined;
+  if (previousSequence !== undefined && event.sequence <= previousSequence) {
+    return { status: "duplicate", cursor };
+  }
+  return {
+    status: previousSequence !== undefined && event.sequence > previousSequence + 1 ? "gap" : "accepted",
+    cursor: { ...cursor, runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
+  };
+}
+function createAgentRuntimeEventSink(config) {
+  const manager = createBoundedSinkManager({
+    write: config.write,
+    ...config.maxPending !== undefined && { maxPending: config.maxPending },
+    ...config.onSinkError && { onSinkError: config.onSinkError },
+    ...config.onDrop && { onDrop: config.onDrop }
+  });
+  return {
+    publish(rawEvent) {
+      const event = AgentRuntimeEventSchema.parse(rawEvent);
+      const projected = config.project?.(event) ?? (config.project ? undefined : event);
+      if (projected)
+        manager.submit(() => AgentRuntimeEventSchema.parse(projected));
+    },
+    flush: () => manager.flush(),
+    getStatus: () => manager.getStatus(),
+    close: () => manager.close()
+  };
+}
+function agentDurableEventId(type, runId, snapshotVersion) {
+  return `${runId}:${type}:${snapshotVersion}`;
+}
 // src/agent-runtime/history.ts
 import { modelMessageSchema } from "ai";
 function providerOptions(envelope) {
@@ -520,26 +485,75 @@ function assistantMessages(message) {
   }
   return messages;
 }
-async function projectAgentHistory(messages, options = {}) {
+function completeToolChronology(message) {
+  const calls = new Set(message.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
+  const results = new Set(message.parts.filter((part) => part.type === "tool-result").map((part) => part.callId));
+  return [...calls].every((callId) => results.has(callId)) && [...results].every((callId) => calls.has(callId));
+}
+async function projectAgentHistoryDetailed(messages, options = {}) {
   const projected = [];
+  const decisions = [];
+  let observedUser = false;
   for (const message of messages) {
-    if (message.status === "streaming" || message.status === "failed")
+    if (message.status === "streaming" || message.status === "failed") {
+      decisions.push({ messageId: message.id, action: "omitted", reason: "draft-or-failed" });
       continue;
+    }
     if (message.role === "user") {
       const user = await userMessage(message, options);
-      if (user)
+      observedUser = true;
+      if (user) {
         projected.push(user);
+        decisions.push({ messageId: message.id, action: "projected", reason: "projected" });
+      } else {
+        decisions.push({ messageId: message.id, action: "omitted", reason: "empty" });
+      }
       continue;
     }
     if (message.role === "system" || message.role === "summary") {
       const content = textContent(message.parts);
-      if (content)
+      if (content) {
         projected.push(modelMessageSchema.parse({ role: "system", content }));
+        decisions.push({ messageId: message.id, action: "projected", reason: "projected" });
+      } else {
+        decisions.push({ messageId: message.id, action: "omitted", reason: "empty" });
+      }
       continue;
     }
-    projected.push(...assistantMessages(message));
+    if (!observedUser && options.leadingAssistant !== "allow") {
+      if (options.leadingAssistant === "error") {
+        throw new Error(`Assistant message ${message.id} precedes the first user message`);
+      }
+      decisions.push({
+        messageId: message.id,
+        action: "omitted",
+        reason: "leading-assistant"
+      });
+      continue;
+    }
+    if (!completeToolChronology(message)) {
+      if (options.incompleteToolTurn === "error") {
+        throw new Error(`Assistant message ${message.id} has incomplete tool chronology`);
+      }
+      decisions.push({
+        messageId: message.id,
+        action: "omitted",
+        reason: "incomplete-tool-turn"
+      });
+      continue;
+    }
+    const assistant = assistantMessages(message);
+    projected.push(...assistant);
+    decisions.push({
+      messageId: message.id,
+      action: assistant.length > 0 ? "projected" : "omitted",
+      reason: assistant.length > 0 ? "projected" : "empty"
+    });
   }
-  return projected;
+  return { messages: projected, decisions };
+}
+async function projectAgentHistory(messages, options = {}) {
+  return [...(await projectAgentHistoryDetailed(messages, options)).messages];
 }
 // src/agent-runtime/managed-tools.ts
 async function assertFence(config, input) {
@@ -565,15 +579,22 @@ 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(),
+  availability: z2.enum(["available", "unavailable"]).optional()
+});
+var AgentModelRegistrySnapshotSchema = z2.object({
+  schemaVersion: z2.literal(1),
+  source: z2.string().min(1),
+  observedAt: z2.iso.datetime({ offset: true }),
+  models: z2.record(z2.string().min(1), AgentModelDescriptorSchema)
 });
 function defineModelRegistry(config) {
   const descriptors = new Map;
@@ -592,15 +613,26 @@ function defineModelRegistry(config) {
     const available = new Set(descriptor(key).capabilities);
     return capabilities.every((capability) => available.has(capability));
   };
+  const preflight = (key, required = []) => {
+    const selected = descriptor(key);
+    if (selected.availability === "unavailable") {
+      throw new Error(`Agent model ${key} is unavailable`);
+    }
+    if (!supports(key, required)) {
+      throw new Error(`Agent model ${key} does not satisfy required capabilities`);
+    }
+    if (!config.providers[selected.provider]) {
+      throw new Error(`Unknown agent model provider: ${selected.provider}`);
+    }
+    return selected;
+  };
   return {
     keys: () => [...descriptors.keys()],
     descriptor,
     supports,
+    preflight,
     resolve(key, required = []) {
-      const selected = descriptor(key);
-      if (!supports(key, required)) {
-        throw new Error(`Agent model ${key} does not satisfy required capabilities`);
-      }
+      const selected = preflight(key, required);
       const provider = config.providers[selected.provider];
       if (!provider)
         throw new Error(`Unknown agent model provider: ${selected.provider}`);
@@ -609,29 +641,49 @@ function defineModelRegistry(config) {
         model: provider.create(selected.modelId),
         ...provider.normalizeUsage && { normalizeUsage: provider.normalizeUsage }
       };
+    },
+    snapshot(input) {
+      return AgentModelRegistrySnapshotSchema.parse({
+        schemaVersion: 1,
+        source: input.source,
+        observedAt: input.observedAt,
+        models: Object.fromEntries(descriptors.entries())
+      });
     }
   };
 }
+function validateAgentModelSnapshot(input, policy) {
+  if (!Number.isSafeInteger(policy.maxAgeMs) || policy.maxAgeMs < 0) {
+    throw new TypeError("maxAgeMs must be a non-negative safe integer");
+  }
+  const snapshot = AgentModelRegistrySnapshotSchema.parse(input);
+  const now = policy.now?.() ?? new Date;
+  const age = now.getTime() - new Date(snapshot.observedAt).getTime();
+  if (age < 0 || age > policy.maxAgeMs) {
+    throw new Error(`Agent model snapshot from ${snapshot.source} is stale`);
+  }
+  return snapshot;
+}
 // 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) {
@@ -642,13 +694,18 @@ function createAgentObservability(config) {
     ...config.onSinkError && { onSinkError: config.onSinkError },
     ...config.onDrop && { onDrop: config.onDrop }
   });
+  const emitted = new Set;
   return {
     rootTrace(parent) {
       const trace = parent ? childSpan(parent) : createTraceContext();
       return trace;
     },
     emit(rawEvent) {
-      manager.submit(() => AgentRunEventSchema.parse(rawEvent));
+      const parsed = AgentRunEventSchema.parse(rawEvent);
+      if ((config.deduplicate ?? true) && emitted.has(parsed.eventId))
+        return;
+      emitted.add(parsed.eventId);
+      manager.submit(() => config.includeInternalCause ? parsed : AgentRunEventSchema.omit({ internalCause: true }).parse(parsed));
     },
     flush: () => manager.flush(),
     getStatus: () => manager.getStatus(),
@@ -656,11 +713,115 @@ 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 completeTurn(messages) {
+  if (messages[0]?.role !== "user")
+    return false;
+  const assistant = messages.find((message) => message.role === "assistant");
+  if (assistant?.status !== "completed")
+    return false;
+  const calls = new Set(assistant.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
+  const results = new Set(assistant.parts.filter((part) => part.type === "tool-result").map((part) => part.callId));
+  return [...calls].every((callId) => results.has(callId)) && [...results].every((callId) => calls.has(callId));
+}
+function budgetTurns(messages) {
+  const turns = [];
+  let current = [];
+  const flush = () => {
+    if (current.length === 0)
+      return;
+    turns.push({ messages: current, complete: completeTurn(current), protectedSystem: false });
+    current = [];
+  };
+  for (const message of messages) {
+    if (message.role === "system" || message.role === "summary") {
+      flush();
+      turns.push({ messages: [message], complete: true, protectedSystem: true });
+      continue;
+    }
+    if (message.role === "user")
+      flush();
+    current.push(message);
+  }
+  flush();
+  return turns;
+}
+async function selectAgentHistory(options) {
+  if (!Number.isSafeInteger(options.availableTokens) || options.availableTokens < 0) {
+    throw new TypeError("availableTokens must be a non-negative safe integer");
+  }
+  const keepRecentTurns = options.keepRecentTurns ?? 1;
+  if (!Number.isSafeInteger(keepRecentTurns) || keepRecentTurns < 0) {
+    throw new TypeError("keepRecentTurns must be a non-negative safe integer");
+  }
+  const counts = new Map;
+  let total = 0;
+  let estimated = false;
+  for (const message of options.messages) {
+    const count = AgentTokenCountSchema.parse(await options.estimateMessage(message));
+    counts.set(message.id, count);
+    const value = knownValue(count);
+    if (value === undefined) {
+      return {
+        messages: [...options.messages],
+        decisions: options.messages.map((candidate) => ({
+          messageId: candidate.id,
+          action: "kept",
+          reason: "token-count-unavailable",
+          tokens: counts.get(candidate.id) ?? { provenance: "unavailable" }
+        })),
+        totalTokens: { provenance: "unavailable" },
+        outcome: "unavailable"
+      };
+    }
+    total += value;
+    if (count.provenance === "estimated")
+      estimated = true;
+  }
+  const turns = budgetTurns(options.messages);
+  const completeIndexes = turns.map((turn, index) => ({ turn, index })).filter(({ turn }) => turn.complete && !turn.protectedSystem).map(({ index }) => index);
+  const protectedRecent = new Set(completeIndexes.slice(-keepRecentTurns));
+  const removed = new Set;
+  for (let index = 0;index < turns.length && total > options.availableTokens; index += 1) {
+    const turn = turns[index];
+    if (!turn || turn.protectedSystem || !turn.complete || protectedRecent.has(index))
+      continue;
+    for (const message of turn.messages) {
+      removed.add(message.id);
+      total -= knownValue(counts.get(message.id) ?? { provenance: "unavailable" }) ?? 0;
+    }
+  }
+  const messages = options.messages.filter((message) => !removed.has(message.id));
+  const decisions = options.messages.map((message) => {
+    const turnIndex = turns.findIndex((turn2) => turn2.messages.some((item) => item.id === message.id));
+    const turn = turns[turnIndex];
+    let reason = "within-budget";
+    if (removed.has(message.id))
+      reason = "oldest-eligible-turn";
+    else if (turn?.protectedSystem)
+      reason = "protected-system";
+    else if (turn && !turn.complete)
+      reason = "protected-incomplete-turn";
+    else if (protectedRecent.has(turnIndex))
+      reason = "protected-recent-turn";
+    return {
+      messageId: message.id,
+      action: removed.has(message.id) ? "removed" : "kept",
+      reason,
+      tokens: counts.get(message.id) ?? { provenance: "unavailable" }
+    };
+  });
+  return {
+    messages,
+    decisions,
+    totalTokens: { value: total, provenance: estimated ? "estimated" : "measured" },
+    outcome: total > options.availableTokens ? "oversized" : removed.size > 0 ? "truncated" : "fits"
+  };
+}
 function knownValue(value) {
   return value.provenance === "unavailable" ? undefined : value.value;
 }
@@ -738,7 +899,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}`);
@@ -757,7 +918,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) {
@@ -899,7 +1060,11 @@ function createAgentRuntime(config) {
   const publish = async (event) => {
     try {
       await config.publish?.(event);
-    } catch {}
+    } catch (error) {
+      try {
+        await config.onPublishError?.({ event, error });
+      } catch {}
+    }
   };
   const executeRun = async (input) => {
     const queuedSnapshot = await config.store.loadSnapshot(input.acceptedRun.conversationId);
@@ -913,7 +1078,7 @@ function createAgentRuntime(config) {
     let run = findRun(acquired.runs, input.acceptedRun.id);
     await publish({
       type: "run-state",
-      eventId: generateId(),
+      eventId: agentDurableEventId("run-state", run.id, acquired.version),
       conversationId: run.conversationId,
       runId: run.id,
       snapshotVersion: acquired.version,
@@ -951,6 +1116,7 @@ function createAgentRuntime(config) {
       runId: run.id,
       expectedRevision: run.revision,
       ownerId: runtimeEpoch,
+      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
       assistant
     }), "assistant draft");
     run = findRun(snapshot.runs, run.id);
@@ -999,16 +1165,24 @@ function createAgentRuntime(config) {
         runId: run.id,
         expectedRevision: run.revision,
         ownerId: runtimeEpoch,
+        ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
         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(),
+        eventId: agentDurableEventId("assistant-checkpoint", run.id, snapshot.version),
         conversationId: run.conversationId,
         runId: run.id,
         snapshotVersion: snapshot.version,
         message: assistant,
+        metrics: checkpointMetrics,
         emittedAt: now().toISOString()
       });
     };
@@ -1029,6 +1203,8 @@ function createAgentRuntime(config) {
         const currentRun = current.runs.find((candidate) => candidate.id === run.id);
         if (!currentRun || currentRun.ownerId !== runtimeEpoch)
           return "stale_run";
+        if (currentRun.fencingToken !== run.fencingToken)
+          return "stale_run";
         if (currentRun.state === "interrupt_requested")
           return "run_interrupted";
         if (currentRun.state !== "running")
@@ -1037,7 +1213,10 @@ function createAgentRuntime(config) {
       };
       const toolFenceLifecycle = createAgentToolFenceLifecycle({
         runId: run.id,
-        assertCurrent
+        assertCurrent,
+        context: () => ({
+          ...run.fencingToken !== undefined && { fencingToken: run.fencingToken }
+        })
       });
       const runtimeContext = {
         context: input.context,
@@ -1373,14 +1552,21 @@ function createAgentRuntime(config) {
       runId: run.id,
       expectedRevision: run.revision,
       ownerId: runtimeEpoch,
+      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
       assistant,
       reason: terminalReason,
       ...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(),
+      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
       type: "run-terminal",
       conversationId: run.conversationId,
       runId: run.id,
@@ -1390,7 +1576,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 },
@@ -1398,13 +1584,14 @@ function createAgentRuntime(config) {
     });
     await publish({
       type: "terminal",
-      eventId: generateId(),
+      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
       conversationId: run.conversationId,
       runId: run.id,
       snapshotVersion: snapshot.version,
       reason: terminalReason,
       ...terminalPolicyName && { policyName: terminalPolicyName },
       message: assistant,
+      metrics: terminalMetrics,
       emittedAt: now().toISOString()
     });
     return {
@@ -1412,9 +1599,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);
@@ -1494,6 +1710,10 @@ function createAgentRuntime(config) {
           await previousAcceptance.catch(() => {
             return;
           });
+          await config.models.preflight?.({
+            context,
+            conversationId: input.conversationId
+          });
           const acceptance = await config.store.acceptInputAndAssignRun({
             idempotencyKey: input.idempotencyKey,
             input: userMessage2,
@@ -1505,14 +1725,45 @@ 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,
-            assistantMessageId: acceptedRun.assistantMessageId,
+            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: assistantPlaceholder.id,
+            input: acceptedInput,
+            run: acceptedRun,
+            assistant: acceptedAssistant,
             snapshotVersion: acceptedSnapshot.version
+          };
+          outerAdmission.resolve(admission);
+          await publish({
+            type: "admission",
+            eventId: agentDurableEventId("admission", acceptedRun.id, acceptedSnapshot.version),
+            conversationId: acceptedRun.conversationId,
+            runId: acceptedRun.id,
+            snapshotVersion: acceptedSnapshot.version,
+            input: acceptedInput,
+            run: acceptedRun,
+            assistant: acceptedAssistant,
+            emittedAt: now().toISOString()
           });
           await publish({
             type: "run-state",
-            eventId: generateId(),
+            eventId: agentDurableEventId("run-state", acceptedRun.id, acceptedSnapshot.version),
             conversationId: acceptedRun.conversationId,
             runId: acceptedRun.id,
             snapshotVersion: acceptedSnapshot.version,
@@ -1597,34 +1848,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);
@@ -1637,7 +1861,7 @@ function createAgentRuntime(config) {
         const interruptedRun = findRun(requested.snapshot.runs, input.runId);
         await publish({
           type: "run-state",
-          eventId: generateId(),
+          eventId: agentDurableEventId("run-state", interruptedRun.id, requested.snapshot.version),
           conversationId: interruptedRun.conversationId,
           runId: interruptedRun.id,
           snapshotVersion: requested.snapshot.version,
@@ -1648,101 +1872,300 @@ 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),
+  fencingToken: AgentRecordVersionSchema.optional(),
   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),
+  fencingToken: AgentRecordVersionSchema.optional(),
   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 snapshotOf(state, messages) {
+  validateAggregate(state, messages);
+  return AgentSnapshotSchema.parse({
+    schemaVersion: 1,
+    conversationId: state.conversationId,
+    version: state.version,
+    messages,
+    runs: state.runs
   });
 }
-function cloneSnapshot(snapshot) {
-  return AgentSnapshotSchema.parse(structuredClone(snapshot));
+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")
@@ -1764,217 +2187,427 @@ 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,
+      fencingToken: (run.fencingToken ?? 0) + 1,
+      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.fencingToken !== undefined && run.fencingToken !== input.fencingToken || 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.fencingToken !== undefined && run.fencingToken !== input.fencingToken || 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,
@@ -1982,6 +2615,7 @@ export {
   AgentMessageStatusSchema,
   AgentModelCapabilitySchema,
   AgentModelDescriptorSchema,
+  AgentModelRegistrySnapshotSchema,
   AgentOpaquePartSchema,
   AgentProviderEnvelopeSchema,
   AgentReasoningDeltaEventSchema,
@@ -1990,10 +2624,14 @@ export {
   AgentReasoningStartEventSchema,
   AgentRecordIdSchema,
   AgentRecordVersionSchema,
+  AgentRecoverableDescriptorSchema,
+  AgentRecoverablePageSchema,
   AgentRunEventSchema,
+  AgentRunMetricsSchema,
   AgentRunSchema,
   AgentRunStateEventSchema,
   AgentRunStateSchema,
+  AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
   AgentSnapshotSchema,
   AgentSourcePartSchema,
@@ -2002,6 +2640,7 @@ export {
   AgentStoreDuplicateSchema,
   AgentStoreMutationResultSchema,
   AgentStoreNotFoundSchema,
+  AgentStoredStateSchema,
   AgentTerminalEventSchema,
   AgentTerminalReasonSchema,
   AgentTextPartSchema,
@@ -2018,14 +2657,21 @@ export {
   RecoverAgentRunSchema,
   ReplaceCompactedRangeSchema,
   RequestRunInterruptSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId,
   composeAgentPrompt,
   createAgentObservability,
   createAgentRuntime,
+  createAgentRuntimeEventSink,
+  createAgentRuntimeStore,
   createAgentSessionCoordinator,
   createAgentToolFenceLifecycle,
   createMemoryAgentRuntimeStore,
   defineAgentProtocol,
   defineModelRegistry,
   projectAgentHistory,
-  structuredCompaction
+  projectAgentHistoryDetailed,
+  selectAgentHistory,
+  structuredCompaction,
+  validateAgentModelSnapshot
 };