stitchkit 0.57.0 → 0.59.0

package/dist/agent-runtime.js

@@ -29,7 +29,7 @@ import {
   AgentToolResultPartSchema,
   AgentUsageSchema,
   AgentUsageValueSchema
-} from "./index-1f4fcj0b.js";
+} from "./index-vtjgx3vv.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -86,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
@@ -335,6 +347,63 @@ var AgentRuntimeEventSchema = z.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) {
@@ -416,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) {
@@ -469,7 +587,14 @@ var AgentModelDescriptorSchema = z2.object({
   contextWindow: z2.int().positive(),
   capabilities: z2.array(AgentModelCapabilitySchema),
   observedAt: z2.iso.datetime({ offset: true }).optional(),
-  source: z2.string().min(1).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;
@@ -488,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}`);
@@ -505,9 +641,29 @@ 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 z3 } from "zod";
 var AgentRunEventSchema = z3.object({
@@ -538,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(),
@@ -557,6 +718,110 @@ 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;
 }
@@ -795,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);
@@ -809,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,
@@ -847,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);
@@ -895,6 +1165,7 @@ 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);
@@ -906,7 +1177,7 @@ function createAgentRuntime(config) {
       };
       await publish({
         type: "assistant-checkpoint",
-        eventId: generateId(),
+        eventId: agentDurableEventId("assistant-checkpoint", run.id, snapshot.version),
         conversationId: run.conversationId,
         runId: run.id,
         snapshotVersion: snapshot.version,
@@ -932,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")
@@ -940,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,
@@ -1276,6 +1552,7 @@ function createAgentRuntime(config) {
       runId: run.id,
       expectedRevision: run.revision,
       ownerId: runtimeEpoch,
+      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
       assistant,
       reason: terminalReason,
       ...terminalPolicyName && { policyName: terminalPolicyName }
@@ -1289,7 +1566,7 @@ function createAgentRuntime(config) {
     };
     config.observe?.emit({
       schemaVersion: 1,
-      eventId: generateId(),
+      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
       type: "run-terminal",
       conversationId: run.conversationId,
       runId: run.id,
@@ -1307,7 +1584,7 @@ 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,
@@ -1433,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,
@@ -1443,7 +1724,7 @@ 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);
+          const acceptedRun = acceptance.outcome === "duplicate" ? acceptance.run : findRun(acceptedSnapshot.runs, assignedRunId);
           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) {
@@ -1458,7 +1739,7 @@ function createAgentRuntime(config) {
             createdAt: acceptedRun.createdAt,
             updatedAt: acceptedRun.updatedAt
           });
-          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptedSnapshot.messages.find((candidate) => candidate.id === acceptedRun.assistantMessageId) ?? assistantPlaceholder : assistantPlaceholder;
+          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptance.assistant ?? assistantPlaceholder : assistantPlaceholder;
           const admission = {
             inputMessageId: acceptedInput.id,
             runId: acceptedRun.id,
@@ -1471,7 +1752,7 @@ function createAgentRuntime(config) {
           outerAdmission.resolve(admission);
           await publish({
             type: "admission",
-            eventId: generateId(),
+            eventId: agentDurableEventId("admission", acceptedRun.id, acceptedSnapshot.version),
             conversationId: acceptedRun.conversationId,
             runId: acceptedRun.id,
             snapshotVersion: acceptedSnapshot.version,
@@ -1482,7 +1763,7 @@ function createAgentRuntime(config) {
           });
           await publish({
             type: "run-state",
-            eventId: generateId(),
+            eventId: agentDurableEventId("run-state", acceptedRun.id, acceptedSnapshot.version),
             conversationId: acceptedRun.conversationId,
             runId: acceptedRun.id,
             snapshotVersion: acceptedSnapshot.version,
@@ -1500,9 +1781,9 @@ function createAgentRuntime(config) {
               }
               return;
             }
-            const message = acceptedSnapshot.messages.find((candidate) => candidate.id === acceptedRun.assistantMessageId);
+            const message = acceptance.assistant;
             if (!message) {
-              const error = new Error("Duplicate terminal run has no assistant message");
+              const error = new Error("Duplicate terminal admission has no retained canonical assistant");
               outerResult.reject(error);
               if (reservation?.shouldSchedule) {
                 reservation.admission.completion.reject(error);
@@ -1580,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,
@@ -1715,6 +1996,8 @@ var AgentStoreDuplicateSchema = z6.object({
   inputMessageId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   assistantMessageId: AgentRecordIdSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional(),
   snapshot: AgentSnapshotSchema
 });
 var AgentStoreMutationResultSchema = z6.discriminatedUnion("outcome", [
@@ -1741,6 +2024,7 @@ var CheckpointRunAssistantSchema = z6.object({
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
   ownerId: z6.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema
 });
 var CommitRunTerminalSchema = z6.object({
@@ -1748,6 +2032,7 @@ var CommitRunTerminalSchema = z6.object({
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
   ownerId: z6.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
   policyName: z6.string().min(1).optional()
@@ -1772,18 +2057,23 @@ var ReplaceCompactedRangeSchema = z6.object({
 });
 // 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 AgentRuntimeHeadSchema = z7.object({
+  schemaVersion: z7.literal(1),
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema
+});
+var AgentStoredRunSchema = z7.object({
+  schemaVersion: z7.literal(1),
+  run: AgentRunSchema,
+  terminalAssistant: AgentMessageSchema.optional()
 });
-var AgentStoredStateSchema = z7.object({
+var AgentAdmissionReceiptSchema = z7.object({
   schemaVersion: z7.literal(1),
   conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  runs: z7.array(AgentRunSchema),
-  admissions: z7.array(AgentAdmissionIdentitySchema)
+  idempotencyKey: z7.string().min(1),
+  input: AgentMessageSchema,
+  runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema
 });
 var AgentHistoryMutationSchema = z7.discriminatedUnion("type", [
   z7.object({ type: z7.literal("admit"), input: AgentMessageSchema }),
@@ -1809,40 +2099,40 @@ var AgentRecoverableScanInputSchema = z7.object({
   cursor: z7.string().min(1).optional(),
   limit: z7.number().int().min(1).max(1000)
 });
-function emptyState(conversationId) {
-  return AgentStoredStateSchema.parse({
+function emptyHead(conversationId) {
+  return AgentRuntimeHeadSchema.parse({
     schemaVersion: 1,
     conversationId,
-    version: 0,
-    runs: [],
-    admissions: []
+    version: 0
   });
 }
-function snapshotOf(state, messages) {
-  validateAggregate(state, messages);
+function snapshotOf(head, messages, records) {
+  validateSnapshot(head, messages, records);
   return AgentSnapshotSchema.parse({
     schemaVersion: 1,
-    conversationId: state.conversationId,
-    version: state.version,
+    conversationId: head.conversationId,
+    version: head.version,
     messages,
-    runs: state.runs
+    runs: records.map((record) => record.run).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
   });
 }
-function validateAggregate(state, messages) {
+function validateSnapshot(head, messages, records) {
   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");
+  for (const record of records) {
+    const run = record.run;
+    if (run.conversationId !== head.conversationId || runIds.has(run.id) || assistantIds.has(run.assistantMessageId)) {
+      throw new TypeError("Stored agent runs contain inconsistent identities");
+    }
+    if (record.terminalAssistant && (record.terminalAssistant.id !== run.assistantMessageId || record.terminalAssistant.conversationId !== run.conversationId || record.terminalAssistant.runId !== run.id || record.terminalAssistant.role !== "assistant" || run.terminalReason === undefined)) {
+      throw new TypeError("Retained terminal assistant does not match its run");
     }
     runIds.add(run.id);
     assistantIds.add(run.assistantMessageId);
   }
   for (const message of messages) {
-    if (message.conversationId !== state.conversationId || messageIds.has(message.id)) {
+    if (message.conversationId !== head.conversationId || messageIds.has(message.id)) {
       throw new TypeError("Stored agent history contains inconsistent message identities");
     }
     messageIds.add(message.id);
@@ -1850,23 +2140,12 @@ function validateAggregate(state, messages) {
       throw new TypeError("Stored history occupies a reserved assistant identity");
     }
     if (message.runId !== undefined) {
-      const run = state.runs.find((candidate) => candidate.id === message.runId);
+      const run = records.find((candidate) => candidate.run.id === message.runId)?.run;
       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) {
@@ -1904,7 +2183,7 @@ function terminalMessageStatus(reason) {
   }
   return "failed";
 }
-function applied(current, admissions, input, historyMutation) {
+function applied(current, input, effects) {
   return {
     outcome: "applied",
     snapshot: AgentSnapshotSchema.parse({
@@ -1913,27 +2192,14 @@ function applied(current, admissions, input, historyMutation) {
       runs: input.runs ?? current.runs,
       messages: input.messages ?? current.messages
     }),
-    admissions,
-    ...historyMutation && { historyMutation }
+    ...effects?.runRecord && { runRecord: effects.runRecord },
+    ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
+    ...effects?.historyMutation && { historyMutation: effects.historyMutation }
   };
 }
-function reduceStore(current, currentAdmissions, operation, duplicateInput) {
+function reduceStore(current, operation) {
   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");
-      }
-      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);
     }
@@ -1950,16 +2216,25 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: coalescedRun.revision + 1,
       updatedAt: new Date().toISOString()
     }) : input.run;
-    const admission = AgentAdmissionIdentitySchema.parse({
+    const admissionReceipt = AgentAdmissionReceiptSchema.parse({
+      schemaVersion: 1,
+      conversationId: input.input.conversationId,
       idempotencyKey: input.idempotencyKey,
-      inputMessageId: input.input.id,
+      input: input.input,
       runId: assignedRun.id,
       assistantMessageId: assignedRun.assistantMessageId
     });
-    return applied(current, [...currentAdmissions, admission], {
+    return applied(current, {
       messages: [...current.messages, input.input],
       runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
-    }, { type: "admit", input: input.input });
+    }, {
+      runRecord: AgentStoredRunSchema.parse({
+        schemaVersion: 1,
+        run: assignedRun
+      }),
+      admissionReceipt,
+      historyMutation: { 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);
@@ -1975,16 +2250,17 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       ...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)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: 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") {
+    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({
@@ -1992,10 +2268,13 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
+    return applied(current, {
       runs: replaceRun(current.runs, next),
       messages: replaceMessage(current.messages, input.assistant)
-    }, { type: "upsert-assistant", message: input.assistant });
+    }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next }),
+      historyMutation: { type: "upsert-assistant", message: input.assistant }
+    });
   }
   if (operation.type === "interrupt" && run) {
     if (run.revision !== operation.input.expectedRevision || run.state !== "running") {
@@ -2007,8 +2286,8 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
-      runs: replaceRun(current.runs, next)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
     });
   }
   if (operation.type === "recover" && run) {
@@ -2046,18 +2325,25 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
         status: "failed",
         updatedAt: new Date().toISOString()
       });
-      return applied(current, currentAdmissions, {
+      return applied(current, {
         runs: replaceRun(current.runs, next),
         messages: replaceMessage(current.messages, assistant)
-      }, { type: "upsert-assistant", message: assistant });
+      }, {
+        runRecord: AgentStoredRunSchema.parse({
+          schemaVersion: 1,
+          run: next,
+          terminalAssistant: assistant
+        }),
+        historyMutation: { type: "upsert-assistant", message: assistant }
+      });
     }
-    return applied(current, currentAdmissions, {
-      runs: replaceRun(current.runs, next)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: 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)) {
+    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({
@@ -2068,10 +2354,17 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
+    return applied(current, {
       runs: replaceRun(current.runs, next),
       messages: replaceMessage(current.messages, input.assistant)
-    }, { type: "upsert-assistant", message: input.assistant });
+    }, {
+      runRecord: AgentStoredRunSchema.parse({
+        schemaVersion: 1,
+        run: next,
+        terminalAssistant: input.assistant
+      }),
+      historyMutation: { type: "upsert-assistant", message: input.assistant }
+    });
   }
   if (operation.type === "compact") {
     const input = operation.input;
@@ -2093,10 +2386,12 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       input.summary,
       ...current.messages.slice(first + positions.length)
     ];
-    return applied(current, currentAdmissions, { messages }, {
-      type: "replace-compacted-range",
-      replacedMessageIds: input.replacedMessageIds,
-      summary: input.summary
+    return applied(current, { messages }, {
+      historyMutation: {
+        type: "replace-compacted-range",
+        replacedMessageIds: input.replacedMessageIds,
+        summary: input.summary
+      }
     });
   }
   return { outcome: "not_found" };
@@ -2104,48 +2399,130 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
 function operationConversationId(operation) {
   return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
 }
+function mergeRunRecords(...groups) {
+  const records = new Map;
+  for (const group of groups) {
+    for (const rawRecord of group) {
+      const record = AgentStoredRunSchema.parse(rawRecord);
+      const previous = records.get(record.run.id);
+      if (previous && previous.run.assistantMessageId !== record.run.assistantMessageId) {
+        throw new TypeError("Stored agent run identity changed across normalized records");
+      }
+      records.set(record.run.id, record);
+    }
+  }
+  return [...records.values()];
+}
+function referencedRunIds(messages) {
+  return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
+}
+function validateAdmissionReceipt(receipt, record, conversationId) {
+  const input = receipt.input;
+  const run = record.run;
+  if (receipt.conversationId !== conversationId || input.conversationId !== conversationId || input.role !== "user" || input.status !== "committed" || input.runId !== undefined || receipt.runId !== run.id || receipt.assistantMessageId !== run.assistantMessageId || !run.inputMessageIds.includes(input.id)) {
+    throw new TypeError("Admission receipt does not match its canonical run assignment");
+  }
+}
 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)
+    const [stored, messages, activeRecords] = await Promise.all([
+      driver.head.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId),
+      driver.runs.listActive(transaction, conversationId)
     ]);
-    return snapshotOf(stored ?? emptyState(conversationId), messages);
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+    const referencedRecords = await driver.runs.loadMany(transaction, {
+      conversationId,
+      runIds: referencedRunIds(messages)
+    });
+    return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
   });
   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 operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
+    const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
+      driver.head.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId),
+      driver.runs.listActive(transaction, conversationId),
+      operationRunId ? driver.runs.load(transaction, { conversationId, runId: operationRunId }) : undefined,
+      operation.type === "accept" ? driver.admissions.load(transaction, {
+        conversationId,
+        idempotencyKey: operation.input.idempotencyKey
+      }) : undefined
     ]);
-    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, {
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+    const referencedRecords = await driver.runs.loadMany(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");
+      runIds: referencedRunIds(messages)
+    });
+    const records = mergeRunRecords(activeRecords, referencedRecords, operationRecord ? [operationRecord] : []);
+    const current = snapshotOf(head, messages, records);
+    if (duplicateReceipt) {
+      const duplicateRecord = await driver.runs.load(transaction, {
+        conversationId,
+        runId: duplicateReceipt.runId
+      });
+      if (!duplicateRecord) {
+        throw new TypeError("Admission receipt points to a missing canonical run");
+      }
+      validateAdmissionReceipt(duplicateReceipt, duplicateRecord, conversationId);
+      return {
+        outcome: "duplicate",
+        input: duplicateReceipt.input,
+        inputMessageId: duplicateReceipt.input.id,
+        runId: duplicateReceipt.runId,
+        assistantMessageId: duplicateReceipt.assistantMessageId,
+        run: duplicateRecord.run,
+        ...duplicateRecord.terminalAssistant && {
+          assistant: duplicateRecord.terminalAssistant
+        },
+        snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord]))
+      };
     }
-    const reduced = reduceStore(current, state.admissions, operation, duplicateInput);
+    if (operation.type === "accept") {
+      const inputCollision = await driver.admissions.loadByInputMessageId(transaction, {
+        conversationId,
+        inputMessageId: operation.input.input.id
+      });
+      if (inputCollision) {
+        throw new TypeError("Input message identity is already assigned to an admission");
+      }
+      if (!operation.input.coalesceIntoRunId) {
+        const [runCollision, assistantCollision] = await Promise.all([
+          driver.runs.load(transaction, {
+            conversationId,
+            runId: operation.input.run.id
+          }),
+          driver.runs.loadByAssistantMessageId(transaction, {
+            conversationId,
+            assistantMessageId: operation.input.run.assistantMessageId
+          })
+        ]);
+        if (runCollision || assistantCollision) {
+          throw new TypeError("Queued run identities are already reserved");
+        }
+      }
+    }
+    const reduced = reduceStore(current, operation);
     if (reduced.outcome !== "applied")
       return reduced;
-    const nextState = AgentStoredStateSchema.parse({
+    const nextHead = AgentRuntimeHeadSchema.parse({
       schemaVersion: 1,
       conversationId,
-      version: reduced.snapshot.version,
-      runs: reduced.snapshot.runs,
-      admissions: reduced.admissions
+      version: reduced.snapshot.version
     });
-    const outcome = await driver.state.compareAndSwap(transaction, {
+    const outcome = await driver.head.compareAndSwap(transaction, {
       conversationId,
       expectedVersion: current.version,
-      next: nextState,
-      recoverable: recoverableDescriptors(nextState)
+      next: nextHead
     });
     if (outcome.outcome === "conflict")
       return conflict(outcome.actualVersion);
+    if (reduced.runRecord)
+      await driver.runs.save(transaction, reduced.runRecord);
+    if (reduced.admissionReceipt) {
+      await driver.admissions.create(transaction, reduced.admissionReceipt);
+    }
     if (reduced.historyMutation) {
       await driver.history.apply(transaction, reduced.historyMutation);
     }
@@ -2197,10 +2574,16 @@ function createAgentRuntimeStore(driver) {
     }
   };
 }
-function cloneStateMap(source) {
+function cloneHeadMap(source) {
   return new Map([...source].map(([key, value]) => [
     key,
-    AgentStoredStateSchema.parse(structuredClone(value))
+    AgentRuntimeHeadSchema.parse(structuredClone(value))
+  ]));
+}
+function cloneNestedMap(source, clone) {
+  return new Map([...source].map(([outerKey, values]) => [
+    outerKey,
+    new Map([...values].map(([innerKey, value]) => [innerKey, clone(value)]))
   ]));
 }
 function cloneHistoryMap(source) {
@@ -2210,9 +2593,10 @@ function cloneHistoryMap(source) {
   ]));
 }
 function createMemoryAgentRuntimeStore() {
-  let states = new Map;
+  let heads = new Map;
+  let runs = new Map;
+  let admissions = new Map;
   let histories = new Map;
-  let archivedMessages = new Map;
   let transactionTail = Promise.resolve();
   const driver = {
     async transaction(work) {
@@ -2225,50 +2609,91 @@ function createMemoryAgentRuntimeStore() {
         return;
       });
       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))
-          ]))
-        ]))
+        heads: cloneHeadMap(heads),
+        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
+        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
+        histories: cloneHistoryMap(histories)
       };
       try {
         const result = await work(transaction);
-        states = transaction.states;
+        heads = transaction.heads;
+        runs = transaction.runs;
+        admissions = transaction.admissions;
         histories = transaction.histories;
-        archivedMessages = transaction.archivedMessages;
         return result;
       } finally {
         release.resolve();
       }
     },
-    state: {
+    head: {
       async load(transaction, conversationId) {
-        const state = transaction.states.get(conversationId);
-        return state ? AgentStoredStateSchema.parse(structuredClone(state)) : undefined;
+        const head = transaction.heads.get(conversationId);
+        return head ? AgentRuntimeHeadSchema.parse(structuredClone(head)) : undefined;
       },
       async compareAndSwap(transaction, input) {
-        const current = transaction.states.get(input.conversationId);
+        const current = transaction.heads.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)));
+        transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema.parse(structuredClone(input.next)));
         return { outcome: "applied" };
       }
     },
+    runs: {
+      async load(transaction, input) {
+        const record = transaction.runs.get(input.conversationId)?.get(input.runId);
+        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+      },
+      async loadByAssistantMessageId(transaction, input) {
+        const record = [...transaction.runs.get(input.conversationId)?.values() ?? []].find((candidate) => candidate.run.assistantMessageId === input.assistantMessageId);
+        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+      },
+      async loadMany(transaction, input) {
+        const records = transaction.runs.get(input.conversationId);
+        return input.runIds.flatMap((runId) => {
+          const record = records?.get(runId);
+          return record ? [AgentStoredRunSchema.parse(structuredClone(record))] : [];
+        });
+      },
+      async listActive(transaction, conversationId) {
+        return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => ["queued", "running", "interrupt_requested"].includes(record.run.state)).map((record) => AgentStoredRunSchema.parse(structuredClone(record)));
+      },
+      async save(transaction, rawRecord) {
+        const record = AgentStoredRunSchema.parse(structuredClone(rawRecord));
+        const conversationRuns = transaction.runs.get(record.run.conversationId) ?? new Map;
+        const collision = [...conversationRuns.values()].find((candidate) => candidate.run.id !== record.run.id && candidate.run.assistantMessageId === record.run.assistantMessageId);
+        if (collision)
+          throw new TypeError("Assistant message identity is already reserved");
+        conversationRuns.set(record.run.id, record);
+        transaction.runs.set(record.run.conversationId, conversationRuns);
+      }
+    },
+    admissions: {
+      async load(transaction, input) {
+        const receipt = transaction.admissions.get(input.conversationId)?.get(input.idempotencyKey);
+        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+      },
+      async loadByInputMessageId(transaction, input) {
+        const receipt = [
+          ...transaction.admissions.get(input.conversationId)?.values() ?? []
+        ].find((candidate) => candidate.input.id === input.inputMessageId);
+        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+      },
+      async create(transaction, rawReceipt) {
+        const receipt = AgentAdmissionReceiptSchema.parse(structuredClone(rawReceipt));
+        const conversationAdmissions = transaction.admissions.get(receipt.conversationId) ?? new Map;
+        if (conversationAdmissions.has(receipt.idempotencyKey) || [...conversationAdmissions.values()].some((candidate) => candidate.input.id === receipt.input.id)) {
+          throw new TypeError("Admission identity is already reserved");
+        }
+        conversationAdmissions.set(receipt.idempotencyKey, receipt);
+        transaction.admissions.set(receipt.conversationId, conversationAdmissions);
+      }
+    },
     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;
@@ -2286,11 +2711,6 @@ function createMemoryAgentRuntimeStore() {
         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,
@@ -2299,7 +2719,7 @@ function createMemoryAgentRuntimeStore() {
       }
     },
     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 descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => ["queued", "running", "interrupt_requested"].includes(record.run.state)).map((record) => ({ conversationId, run: record.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);
@@ -2317,7 +2737,7 @@ export {
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionEventSchema,
-  AgentAdmissionIdentitySchema,
+  AgentAdmissionReceiptSchema,
   AgentAssistantPlaceholderSchema,
   AgentCheckpointEventSchema,
   AgentControlPartSchema,
@@ -2331,6 +2751,7 @@ export {
   AgentMessageStatusSchema,
   AgentModelCapabilitySchema,
   AgentModelDescriptorSchema,
+  AgentModelRegistrySnapshotSchema,
   AgentOpaquePartSchema,
   AgentProviderEnvelopeSchema,
   AgentReasoningDeltaEventSchema,
@@ -2346,7 +2767,9 @@ export {
   AgentRunSchema,
   AgentRunStateEventSchema,
   AgentRunStateSchema,
+  AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
+  AgentRuntimeHeadSchema,
   AgentSnapshotSchema,
   AgentSourcePartSchema,
   AgentStoreAppliedSchema,
@@ -2354,7 +2777,7 @@ export {
   AgentStoreDuplicateSchema,
   AgentStoreMutationResultSchema,
   AgentStoreNotFoundSchema,
-  AgentStoredStateSchema,
+  AgentStoredRunSchema,
   AgentTerminalEventSchema,
   AgentTerminalReasonSchema,
   AgentTextPartSchema,
@@ -2371,9 +2794,12 @@ export {
   RecoverAgentRunSchema,
   ReplaceCompactedRangeSchema,
   RequestRunInterruptSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId,
   composeAgentPrompt,
   createAgentObservability,
   createAgentRuntime,
+  createAgentRuntimeEventSink,
   createAgentRuntimeStore,
   createAgentSessionCoordinator,
   createAgentToolFenceLifecycle,
@@ -2381,5 +2807,8 @@ export {
   defineAgentProtocol,
   defineModelRegistry,
   projectAgentHistory,
-  structuredCompaction
+  projectAgentHistoryDetailed,
+  selectAgentHistory,
+  structuredCompaction,
+  validateAgentModelSnapshot
 };