stitchkit 0.110.2 → 0.110.4

package/dist/{index-s2bgwsyr.js → index-mpg1t7nv.js}

@@ -11,7 +11,6 @@ import {
   AgentTimestampSchema2,
   AgentMessageSchema2,
   runStateForTerminalReason2,
-  AgentUsageSchema2,
   AgentRunSchema2,
   AgentSnapshotSchema2
 } from "./index-8kzct1d6.js";
@@ -31,12 +30,16 @@ import {
   SeedConversationInputSchema2,
   AgentRecoverablePageSchema2,
   AgentStoreTransitionSchema2,
+  AgentStoreCheckpointRecordSchema,
   agentStoreEventDraft,
   canonicalAgentJson2,
   encodeAgentConversationArchive2,
   decodeAgentConversationArchive2,
-  assistantStatus
-} from "./index-6qeqdz0z.js";
+  assistantStatus,
+  ProviderJournalMessageSchema,
+  ProviderJournalRequestSchema,
+  ProviderJournalResponseSchema
+} from "./index-jna0ejsa.js";
 import {
   StepEventPayloadSchema,
   ParkEventPayloadSchema,
@@ -173,8 +176,15 @@ function emptyHead(conversationId) {
 import { z as z15 } from "zod";
 
 // src/agent-runtime/store-archive.ts
+import { z as z5 } from "zod";
+
+// src/agent-runtime/branch-replay.ts
+import { createHash as createHash2 } from "node:crypto";
 import { z as z4 } from "zod";
 
+// src/agent-runtime/store-reducer.ts
+import { createHash } from "node:crypto";
+
 // src/agent-runtime/store-snapshot.ts
 function historyPositions(messages) {
   const positions = new Map;
@@ -295,1136 +305,1074 @@ function referencedRunIds(messages) {
   return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
 }
 
-// src/agent-runtime/store-reads.ts
-async function snapshotIn(driver, transaction, conversationId) {
-  const [stored, messages, activeRecords] = await Promise.all([
-    driver.head.load(transaction, conversationId),
-    driver.history.load(transaction, conversationId),
-    driver.runs.listActive(transaction, conversationId)
-  ]);
-  const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(conversationId));
-  const referencedRecords = await driver.runs.loadMany(transaction, {
-    conversationId,
-    runIds: referencedRunIds(messages)
-  });
-  return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
+// src/agent-runtime/store-reduce-shared.ts
+function conflict(actualVersion) {
+  return { outcome: "conflict", actualVersion };
 }
-function loadSnapshot(driver, conversationId) {
-  return driver.transaction((transaction) => snapshotIn(driver, transaction, conversationId), {
-    access: "read"
+function applied(current, input, effects) {
+  const runs = input.runs ?? current.runs;
+  const messages = input.messages ?? current.messages;
+  return {
+    outcome: "applied",
+    snapshot: AgentSnapshotSchema2.parse({
+      ...current,
+      version: current.version + 1,
+      runs,
+      messages: orderRunMessages(messages, runs)
+    }),
+    ...effects?.runRecords?.length && { runRecords: effects.runRecords },
+    ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
+    ...effects?.seedReceipt && { seedReceipt: effects.seedReceipt },
+    ...effects?.historyMutations?.length && { historyMutations: effects.historyMutations }
+  };
+}
+
+// src/agent-runtime/store-reduce-history.ts
+function reduceAccept(current, input) {
+  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.executionSequence !== undefined || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" && input.input.role !== "tool" || 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 ? AgentRunSchema2.parse({
+    ...coalescedRun,
+    inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
+    revision: coalescedRun.revision + 1,
+    updatedAt: new Date().toISOString()
+  }) : input.run;
+  const admissionReceipt = AgentAdmissionReceiptSchema2.parse({
+    schemaVersion: 1,
+    conversationId: input.input.conversationId,
+    idempotencyKey: input.idempotencyKey,
+    input: input.input,
+    runId: assignedRun.id,
+    assistantMessageId: assignedRun.assistantMessageId
+  });
+  return applied(current, {
+    messages: [...current.messages, input.input],
+    runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
+  }, {
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: assignedRun })],
+    admissionReceipt,
+    historyMutations: [{ type: "admit", input: input.input }]
   });
 }
-function loadRun(driver, input) {
-  return driver.transaction(async (transaction) => {
-    const [stored, record] = await Promise.all([
-      driver.head.load(transaction, input.conversationId),
-      driver.runs.load(transaction, input)
-    ]);
-    if (!record)
-      return;
-    const parsed = AgentStoredRunSchema2.parse(record);
-    if (parsed.run.conversationId !== input.conversationId || parsed.run.id !== input.runId) {
-      throw new TypeError("Stored run does not match the identity it was loaded by");
+function reduceSeed(current, input) {
+  const conversationId = input.conversationId;
+  if (current.conversationId !== conversationId)
+    return { outcome: "not_found" };
+  for (const message of input.inputs) {
+    if (message.conversationId !== conversationId || message.role !== "user" || message.status !== "committed" || message.runId !== undefined) {
+      throw new TypeError("Seeded conversation input must be committed unowned user messages");
     }
-    const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(input.conversationId));
-    return AgentRunViewSchema2.parse({
-      snapshotVersion: head.version,
-      run: parsed.run,
-      ...parsed.terminalAssistant && { assistant: parsed.terminalAssistant }
-    });
-  }, { access: "read" });
+  }
+  return applied(current, { messages: [...input.inputs, ...current.messages] }, {
+    seedReceipt: AgentSeedReceiptSchema2.parse({
+      schemaVersion: 1,
+      conversationId,
+      seedKey: input.seedKey,
+      messageIds: input.inputs.map((message) => message.id)
+    }),
+    historyMutations: [...input.inputs].reverse().map((message) => ({
+      type: "seed",
+      message
+    }))
+  });
 }
-function listActiveRuns(driver, conversationId) {
-  return driver.transaction(async (transaction) => {
-    const [records, messages] = await Promise.all([
-      driver.runs.listActive(transaction, conversationId),
-      driver.history.load(transaction, conversationId)
-    ]);
-    const runs = records.map((record) => AgentStoredRunSchema2.parse(record).run);
-    for (const run of runs) {
-      if (run.conversationId !== conversationId) {
-        throw new TypeError("Active run belongs to another conversation");
-      }
-      if (!isActiveRunState(run.state)) {
-        throw new TypeError("Active run listing returned a terminal run");
+function reduceCompact(current, input) {
+  if (current.conversationId !== input.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 liveAssistant = current.runs.find((candidate) => isActiveRunState(candidate.state) && replaced.has(candidate.assistantMessageId));
+  if (liveAssistant) {
+    throw new TypeError(`Compaction may not replace the assistant message of run ${liveAssistant.id}, which has not finished`);
+  }
+  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, { messages }, {
+    historyMutations: [
+      {
+        type: "replace-compacted-range",
+        replacedMessageIds: input.replacedMessageIds,
+        summary: input.summary
       }
-    }
-    return orderRuns(messages, runs);
-  }, { access: "read" });
+    ]
+  });
 }
-function appendEvent(driver, input) {
-  const parsed = AppendAgentStoreEventSchema2.parse(input);
-  return driver.transaction((transaction) => appendEventIn(driver, transaction, parsed));
+
+// src/agent-runtime/store-reduce-run.ts
+function reduceAcquire(current, run, input) {
+  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 !== input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema2.parse({
+    ...run,
+    state: "running",
+    executionSequence: run.executionSequence ?? current.version + 1,
+    ownerId: input.ownerId,
+    fencingToken: (run.fencingToken ?? 0) + 1,
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
+  });
 }
-async function appendEventIn(driver, transaction, parsed) {
-  if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
-    throw new AgentConversationPurgedError2;
+function reduceCheckpoint(current, run, 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);
   }
-  return driver.events.append(transaction, agentStoreEventDraft(parsed));
+  const next = AgentRunSchema2.parse({
+    ...run,
+    ...input.usage && { usage: input.usage },
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, {
+    runs: replaceRun(current.runs, next),
+    messages: replaceMessage(current.messages, input.assistant)
+  }, {
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })],
+    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
+  });
 }
-function readEvents(driver, input) {
-  const parsed = ReadAgentStoreEventsSchema2.parse(input);
-  return driver.transaction(async (transaction) => AgentStoreEventPageSchema2.parse(await driver.events.list(transaction, parsed)), { access: "read" });
+function reduceOperation(current, run, input) {
+  if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken) {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema2.parse({
+    ...run,
+    lastOperation: input.operation,
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, { runs: replaceRun(current.runs, next) }, { runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })] });
 }
-
-// src/agent-runtime/store-archive.ts
-function exportConversation(driver, conversationId) {
-  return driver.transaction(async (transaction) => {
-    return exportConversationIn(driver, transaction, conversationId);
-  }, { access: "read" });
+function reduceInterrupt(current, run, input) {
+  if (run.revision !== input.expectedRevision || run.state !== "running") {
+    return conflict(run.revision);
+  }
+  const next = AgentRunSchema2.parse({
+    ...run,
+    state: "interrupt_requested",
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
+  });
 }
-async function importConversation(driver, bytes) {
-  const archive = decodeAgentConversationArchive2(bytes);
-  return driver.transaction(async (transaction) => {
-    const existing = await driver.events.list(transaction, {
-      conversationId: archive.conversationId,
-      limit: 1
-    });
-    if (existing.items.length > 0) {
-      throw new TypeError("Conversation event log must be empty before import");
-    }
-    for (const event of archive.events) {
-      const appended = await driver.events.append(transaction, {
-        schemaVersion: event.schemaVersion,
-        eventId: event.eventId,
-        conversationId: event.conversationId,
-        kind: event.kind,
-        occurredAt: event.occurredAt,
-        payload: event.payload,
-        ...event.ignorable && { ignorable: true }
-      });
-      if (appended.seq !== event.seq) {
-        throw new TypeError("Conversation archive event sequence is not contiguous");
-      }
-    }
-    const snapshotEntry = archive.projections.find((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.archiveType === "runtime-snapshot");
-    if (snapshotEntry && typeof snapshotEntry === "object" && !Array.isArray(snapshotEntry)) {
-      const snapshot = AgentSnapshotSchema2.parse(snapshotEntry.snapshot);
-      if (snapshot.conversationId !== archive.conversationId) {
-        throw new TypeError("Conversation archive snapshot belongs to another conversation");
-      }
-      if (snapshot.version > 0 || snapshot.messages.length > 0 || snapshot.runs.length > 0) {
-        const outcome = await driver.head.compareAndSwap(transaction, {
-          conversationId: snapshot.conversationId,
-          expectedVersion: 0,
-          next: AgentRuntimeHeadSchema2.parse({
-            schemaVersion: 1,
-            conversationId: snapshot.conversationId,
-            version: snapshot.version
-          })
-        });
-        if (outcome.outcome !== "applied") {
-          throw new TypeError("Conversation archive snapshot target is not empty");
-        }
-      }
-      for (const run of snapshot.runs) {
-        const terminalAssistant = snapshot.messages.find((message) => message.id === run.assistantMessageId);
-        await driver.runs.save(transaction, AgentStoredRunSchema2.parse({
-          schemaVersion: 1,
-          run,
-          ...terminalAssistant && { terminalAssistant }
-        }));
-      }
-      for (const message of snapshot.messages) {
-        await driver.history.apply(transaction, { type: "admit", input: message });
-      }
-      for (const event of archive.events) {
-        if (event.kind !== "runtime/transition")
-          continue;
-        const transition = AgentStoreTransitionSchema2.parse(event.payload);
-        if (transition.type !== "accept")
-          continue;
-        const assigned = snapshot.runs.find((run) => run.inputMessageIds.includes(transition.input.input.id));
-        if (!assigned) {
-          throw new TypeError("Conversation archive admission has no assigned run");
-        }
-        await driver.admissions.create(transaction, AgentAdmissionReceiptSchema2.parse({
+function reduceRecover(current, run, input, retainedAssistant) {
+  if (run.revision !== input.expectedRevision || !isActiveRunState(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 { ownerId: _released, ...carried } = run;
+  const next = AgentRunSchema2.parse({
+    ...carried,
+    state: input.action === "requeue" ? "queued" : "abandoned",
+    revision: run.revision + 1,
+    ...input.action === "abandon" && { terminalReason: "abandoned" },
+    updatedAt: new Date().toISOString()
+  });
+  if (input.action === "abandon") {
+    if (retainedAssistant && (retainedAssistant.id !== run.assistantMessageId || retainedAssistant.conversationId !== run.conversationId || retainedAssistant.runId !== run.id || retainedAssistant.role !== "assistant" || retainedAssistant.status !== "failed"))
+      throw new TypeError("Abandoned assistant does not match its run");
+    const existingAssistant = current.messages.find((message) => message.id === run.assistantMessageId);
+    const assistant = retainedAssistant ?? AgentMessageSchema2.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()
+    });
+    return applied(current, {
+      runs: replaceRun(current.runs, next),
+      messages: replaceMessage(current.messages, assistant)
+    }, {
+      runRecords: [
+        AgentStoredRunSchema2.parse({
           schemaVersion: 1,
-          conversationId: archive.conversationId,
-          idempotencyKey: transition.input.idempotencyKey,
-          input: transition.input.input,
-          runId: assigned.id,
-          assistantMessageId: assigned.assistantMessageId
-        }));
-      }
-    }
-    await driver.archive?.import(transaction, archive);
-    return { conversationId: archive.conversationId, events: archive.events.length };
+          run: next,
+          terminalAssistant: assistant
+        })
+      ],
+      historyMutations: [{ type: "upsert-assistant", message: assistant }]
+    });
+  }
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
   });
 }
-async function exportConversationIn(driver, transaction, conversationId) {
-  const events = [];
-  let fromSeq;
-  do {
-    const page = AgentStoreEventPageSchema2.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema2.parse({
-      conversationId,
-      ...fromSeq && { fromSeq },
-      limit: 1e4
-    })));
-    events.push(...page.items);
-    fromSeq = page.nextSeq;
-  } while (fromSeq !== undefined);
-  const durable = await driver.archive?.export(transaction, conversationId) ?? {
-    projections: [],
-    spills: []
-  };
-  const snapshot = await snapshotIn(driver, transaction, conversationId);
-  return encodeAgentConversationArchive2({
-    format: "stitchkit.agent-conversation",
-    formatVersion: 1,
-    conversationId,
-    events,
-    projections: [
-      { archiveType: "runtime-snapshot", snapshot: z4.json().parse(snapshot) },
-      ...durable.projections
+
+// src/agent-runtime/store-reduce-terminal.ts
+function reduceTerminal(current, run, input) {
+  if (input.reason === "absorbed") {
+    throw new TypeError("A run is absorbed by another run, never terminalized as absorbed");
+  }
+  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 !== assistantStatus(input.reason)) {
+    return conflict(run.revision);
+  }
+  if (input.absorb && runStateForTerminalReason2(input.reason) !== "completed") {
+    throw new TypeError("Only a completing run may absorb a queued successor");
+  }
+  const named = new Set((input.absorb ?? []).map((entry) => entry.runId));
+  if (named.size !== (input.absorb ?? []).length || named.has(run.id)) {
+    throw new TypeError("An absorption names each successor once, and never the absorbing run");
+  }
+  const absorbable = (input.absorb ?? []).filter((entry) => {
+    const candidate = current.runs.find((item) => item.id === entry.runId);
+    return candidate !== undefined && candidate.id !== run.id && candidate.state === "queued" && candidate.conversationId === run.conversationId && candidate.inputMessageIds.length === entry.inputMessageIds.length && candidate.inputMessageIds.every((id, index) => id === entry.inputMessageIds[index]);
+  });
+  const absorbedIds = new Set(absorbable.flatMap((entry) => entry.inputMessageIds));
+  const next = AgentRunSchema2.parse({
+    ...run,
+    state: runStateForTerminalReason2(input.reason),
+    terminalReason: input.reason,
+    ...input.policyName && { terminalPolicyName: input.policyName },
+    ...input.usage && { usage: input.usage },
+    ...absorbedIds.size > 0 && {
+      inputMessageIds: [
+        ...run.inputMessageIds,
+        ...[...absorbedIds].filter((id) => !run.inputMessageIds.includes(id))
+      ]
+    },
+    revision: run.revision + 1,
+    updatedAt: new Date().toISOString()
+  });
+  const absorbedRuns = absorbable.map((entry) => {
+    const candidate = current.runs.find((item) => item.id === entry.runId);
+    if (!candidate)
+      throw new TypeError("Absorbed run disappeared inside the reducer");
+    return AgentRunSchema2.parse({
+      ...candidate,
+      state: runStateForTerminalReason2("absorbed"),
+      terminalReason: "absorbed",
+      absorbedIntoRunId: next.id,
+      revision: candidate.revision + 1,
+      updatedAt: new Date().toISOString()
+    });
+  });
+  const runs = absorbedRuns.reduce((accumulated, absorbed) => replaceRun(accumulated, absorbed), replaceRun(current.runs, next));
+  return applied(current, {
+    runs,
+    messages: replaceMessage(current.messages, input.assistant)
+  }, {
+    runRecords: [
+      AgentStoredRunSchema2.parse({
+        schemaVersion: 1,
+        run: next,
+        terminalAssistant: input.assistant
+      }),
+      ...absorbedRuns.map((absorbed) => AgentStoredRunSchema2.parse({ schemaVersion: 1, run: absorbed }))
     ],
-    spills: durable.spills
+    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
   });
 }
 
-// src/agent-runtime/store-branch.ts
-import { createHash as createHash7 } from "node:crypto";
-import { z as z13 } from "zod";
-
-// src/agent-runtime/branch-events.ts
-import { z as z10 } from "zod";
-
-// src/agent-runtime/branch-messages.ts
-import { z as z5 } from "zod";
-function branchOpaqueJson(value) {
-  if (Array.isArray(value))
-    return value.map(branchOpaqueJson);
-  if (value !== null && typeof value === "object") {
-    for (const key of [
-      "reference",
-      "conversationId",
-      "runId",
-      "messageId",
-      "callId",
-      "toolCallId",
-      "approvalId",
-      "operationId",
-      "artifactId"
-    ]) {
-      if (key in value)
-        throw new TypeError(`Branch cannot rekey an opaque payload containing ${key}`);
+// src/agent-runtime/store-reducer.ts
+function transitionRecord(operation, reduced) {
+  if (operation.type === "recover" && operation.input.action === "abandon") {
+    const assistant = reduced?.runRecords?.find((record) => record.run.id === operation.input.runId)?.terminalAssistant;
+    if (assistant)
+      return { ...operation, assistant };
+  }
+  if (operation.type !== "checkpoint")
+    return operation;
+  const { assistant, ...rest } = operation.input;
+  const body = canonicalAgentJson2(assistant);
+  return AgentStoreCheckpointRecordSchema.parse({
+    type: operation.type,
+    input: {
+      ...rest,
+      assistant: {
+        id: assistant.id,
+        status: assistant.status,
+        sha256: createHash("sha256").update(body).digest("hex"),
+        parts: assistant.parts.length,
+        bytes: Buffer.byteLength(body)
+      }
     }
-    for (const entry of Object.values(value))
-      branchOpaqueJson(entry);
+  });
+}
+function reduceStore(current, operation) {
+  if (operation.type === "accept")
+    return reduceAccept(current, operation.input);
+  if (operation.type === "seed")
+    return reduceSeed(current, operation.input);
+  if (operation.type === "compact")
+    return reduceCompact(current, operation.input);
+  const run = current.runs.find((candidate) => candidate.id === operation.input.runId);
+  if (!run)
+    return { outcome: "not_found" };
+  switch (operation.type) {
+    case "acquire":
+      return reduceAcquire(current, run, operation.input);
+    case "checkpoint":
+      return reduceCheckpoint(current, run, operation.input);
+    case "operation":
+      return reduceOperation(current, run, operation.input);
+    case "interrupt":
+      return reduceInterrupt(current, run, operation.input);
+    case "recover":
+      return reduceRecover(current, run, operation.input, operation.assistant);
+    case "terminal":
+      return reduceTerminal(current, run, operation.input);
   }
-  return value;
 }
-var ArtifactReadSchema = z5.object({
-  reference: z5.string(),
-  offset: z5.int().nonnegative(),
-  maxBytes: z5.int().positive().optional()
+function operationConversationId(operation) {
+  return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
+}
+
+// src/agent-runtime/branch-replay.ts
+var BranchBaselineSchema = z4.object({
+  migratedAt: z4.iso.datetime({ offset: true }),
+  asOf: z4.iso.datetime({ offset: true }).optional(),
+  head: AgentRuntimeHeadSchema2,
+  messages: z4.array(AgentMessageSchema2),
+  compacted: z4.array(z4.string().min(1)).optional(),
+  runs: z4.array(AgentStoredRunSchema2),
+  admissions: z4.array(AgentAdmissionReceiptSchema2)
 }).strict();
-var ArtifactSearchSchema = z5.object({
-  reference: z5.string(),
-  query: z5.string(),
-  maxMatches: z5.int().positive().optional()
-}).strict();
-var ArtifactReadResultSchema = z5.object({
-  reference: z5.string(),
-  offset: z5.int().nonnegative(),
-  text: z5.string(),
-  bytes: z5.int().nonnegative(),
-  totalBytes: z5.int().nonnegative().optional()
-}).strict();
-var ArtifactSearchResultSchema = z5.object({
-  reference: z5.string(),
-  matches: z5.array(z5.object({ line: z5.int().positive(), text: z5.string() }).strict())
-}).strict();
-function branchToolJson(ids, name, value, output) {
-  if (name === AGENT_CODING_TOOL_NAMES.readOutput || name === AGENT_CODING_TOOL_NAMES.searchOutput) {
-    const parsed = output ? name === AGENT_CODING_TOOL_NAMES.readOutput ? ArtifactReadResultSchema.parse(value) : ArtifactSearchResultSchema.parse(value) : name === AGENT_CODING_TOOL_NAMES.readOutput ? ArtifactReadSchema.parse(value) : ArtifactSearchSchema.parse(value);
-    return { ...parsed, reference: ids.reference("spill", parsed.reference) };
-  }
-  if (output && name === AGENT_CODING_TOOL_NAMES.runCommand) {
-    const parsed = ShellOutputSchema.parse(value);
-    return {
-      ...parsed,
-      ...parsed.artifact && {
-        artifact: {
-          ...parsed.artifact,
-          reference: ids.reference("spill", parsed.artifact.reference)
-        }
+function branchTransition(event) {
+  const checkpoint = AgentStoreCheckpointRecordSchema.safeParse(event.payload);
+  if (!checkpoint.success)
+    return AgentStoreTransitionSchema2.parse(event.payload);
+  const input = checkpoint.data.input;
+  if (canonicalAgentJson2(checkpoint.data) !== canonicalAgentJson2(event.payload))
+    throw new TypeError("Branch checkpoint contains an unknown opaque field");
+  return AgentStoreTransitionSchema2.parse({
+    type: "checkpoint",
+    input: {
+      ...input,
+      assistant: {
+        schemaVersion: 1,
+        id: input.assistant.id,
+        conversationId: input.conversationId,
+        runId: input.runId,
+        role: "assistant",
+        status: "streaming",
+        parts: [],
+        createdAt: event.occurredAt,
+        updatedAt: event.occurredAt
       }
-    };
-  }
-  return branchOpaqueJson(value);
+    }
+  });
 }
-function branchPart(ids, part) {
-  switch (part.type) {
-    case "file":
-      return { ...part, reference: ids.reference("spill", part.reference) };
-    case "tool-call": {
-      if (part.provider)
-        throw new TypeError("Branch cannot rekey opaque tool provider metadata");
-      return {
-        ...part,
-        callId: ids.reference("call", part.callId),
-        input: branchToolJson(ids, part.toolName, part.input, false)
-      };
+function replayBranchEvents(conversationId, events, retainedSnapshot) {
+  const result = {
+    snapshot: AgentSnapshotSchema2.parse({
+      schemaVersion: 1,
+      conversationId,
+      version: 0,
+      messages: [],
+      runs: []
+    }),
+    effects: [],
+    unresolvedDrafts: new Set,
+    retainedMessages: new Map
+  };
+  for (const event of events) {
+    if (event.kind === "runtime/baseline") {
+      if (event.seq !== 1 || result.snapshot.version !== 0)
+        throw new TypeError("Branch baseline must be the first event");
+      const baseline = BranchBaselineSchema.parse(event.payload);
+      if (baseline.head.conversationId !== conversationId)
+        throw new TypeError("Branch baseline has a foreign conversation");
+      const compacted = new Set(baseline.compacted);
+      snapshotOf(baseline.head, baseline.messages, baseline.runs);
+      const keys = new Set;
+      for (const record of baseline.runs) {
+        if (record.run.inputMessageIds.some((id) => !baseline.messages.some((message) => message.id === id)))
+          throw new TypeError("Branch baseline run references missing input");
+      }
+      for (const admission of baseline.admissions) {
+        const run = baseline.runs.find((record) => record.run.id === admission.runId)?.run;
+        if (keys.has(admission.idempotencyKey) || admission.conversationId !== conversationId || admission.input.conversationId !== conversationId || !run || !run.inputMessageIds.includes(admission.input.id) || run.assistantMessageId !== admission.assistantMessageId || !baseline.messages.some((message) => message.id === admission.input.id && canonicalAgentJson2(message) === canonicalAgentJson2(admission.input)))
+          throw new TypeError("Branch baseline admission is inconsistent");
+        keys.add(admission.idempotencyKey);
+      }
+      if (compacted.size !== (baseline.compacted?.length ?? 0) || [...compacted].some((id) => !baseline.messages.some((m) => m.id === id)))
+        throw new TypeError("Branch baseline compacted identities are inconsistent");
+      result.snapshot = snapshotOf(baseline.head, baseline.messages.filter((m) => !compacted.has(m.id)), baseline.runs);
+      result.baseline = baseline;
+      continue;
     }
-    case "tool-result":
-      return {
-        ...part,
-        callId: ids.reference("call", part.callId),
-        ...part.output !== undefined && {
-          output: part.outcome === "success" ? branchToolJson(ids, part.toolName, part.output, true) : branchOpaqueJson(part.output)
-        }
-      };
-    case "tool-approval-request":
-      return {
-        type: part.type,
-        approvalId: ids.reference("approval", part.approvalId),
-        callId: ids.reference("call", part.callId)
+    if (event.kind === "runtime/branched") {
+      const receipt = AgentConversationBranchReceiptSchema2.parse(event.payload);
+      if (receipt.conversationId !== conversationId)
+        throw new TypeError("Branch receipt has a foreign conversation");
+      result.snapshot = {
+        ...result.snapshot,
+        runs: result.snapshot.runs.map(({ ownerId: _owner, fencingToken: _fence, ...run }) => run)
       };
-    case "tool-approval-response":
-      return { ...part, approvalId: ids.reference("approval", part.approvalId) };
-    case "provider":
-      throw new TypeError("Branch cannot rekey an opaque provider part");
-    case "reasoning":
-      if (part.provider)
-        throw new TypeError("Branch cannot rekey opaque reasoning provider metadata");
-      return part;
-    default:
-      return part;
+      continue;
+    }
+    if (event.kind !== "runtime/transition")
+      continue;
+    let operation = branchTransition(event);
+    if (operation.type === "checkpoint" && retainedSnapshot) {
+      const record = AgentStoreCheckpointRecordSchema.safeParse(event.payload);
+      const assistantId = operation.input.assistant.id;
+      const retained = retainedSnapshot.messages.find((message) => message.id === assistantId);
+      if (record.success && retained && record.data.input.assistant.sha256 === createHash2("sha256").update(canonicalAgentJson2(retained)).digest("hex")) {
+        operation = { ...operation, input: { ...operation.input, assistant: retained } };
+        result.retainedMessages.set(event.eventId, retained);
+      }
+    }
+    if (operation.type === "recover" && operation.input.action === "abandon" && !operation.assistant && retainedSnapshot) {
+      const runId = operation.input.runId;
+      const run = result.snapshot.runs.find((run) => run.id === runId);
+      const retained = retainedSnapshot.messages.find((message) => message.id === run?.assistantMessageId && message.runId === runId && message.role === "assistant" && message.status === "failed");
+      if (retained)
+        operation = { ...operation, assistant: retained };
+    }
+    if (operation.type === "recover" && operation.input.action === "abandon" && !operation.assistant)
+      throw new TypeError("Branch archive has no exact retained abandoned assistant");
+    const inputConversation = operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
+    if (inputConversation !== conversationId)
+      throw new TypeError("Branch transition has a foreign conversation");
+    const reduced = reduceStore(result.snapshot, operation);
+    if (reduced.outcome !== "applied")
+      throw new TypeError(`Branch transition at sequence ${event.seq} is inconsistent: ${reduced.outcome}`);
+    const runRecords = reduced.runRecords?.map((record) => ({
+      ...record,
+      run: { ...record.run, updatedAt: event.occurredAt }
+    }));
+    result.snapshot = {
+      ...reduced.snapshot,
+      runs: reduced.snapshot.runs.map((run) => runRecords?.find((record) => record.run.id === run.id)?.run ?? run)
+    };
+    const { snapshot: _snapshot, outcome: _outcome, ...effects } = reduced;
+    result.effects.push({ ...effects, ...runRecords && { runRecords } });
+    if (operation.type === "recover" && operation.input.action === "abandon") {
+      const runId = operation.input.runId;
+      const assistant = reduced.runRecords?.find((record) => record.run.id === runId)?.terminalAssistant;
+      if (assistant)
+        result.retainedMessages.set(event.eventId, assistant);
+      if (operation.assistant)
+        result.unresolvedDrafts.delete(runId);
+    }
+    if (operation.type === "checkpoint" && AgentStoreCheckpointRecordSchema.safeParse(event.payload).success)
+      result.unresolvedDrafts.add(operation.input.runId);
+    if (operation.type === "terminal")
+      result.unresolvedDrafts.delete(operation.input.runId);
   }
+  return result;
 }
-function branchMessage(ids, sourceConversationId, message) {
-  if (message.conversationId !== sourceConversationId)
-    throw new TypeError("Branch message belongs to another conversation");
-  return {
-    ...message,
-    id: ids.reference("message", message.id),
-    conversationId: ids.conversationId,
-    ...message.runId && { runId: ids.reference("run", message.runId) },
-    parts: message.parts.map((part) => branchPart(ids, part)),
-    ...message.metadata && {
-      metadata: z5.record(z5.string(), z5.json()).parse(branchOpaqueJson(message.metadata))
+
+// src/agent-runtime/store-reads.ts
+async function snapshotIn(driver, transaction, conversationId) {
+  const [stored, messages, activeRecords] = await Promise.all([
+    driver.head.load(transaction, conversationId),
+    driver.history.load(transaction, conversationId),
+    driver.runs.listActive(transaction, conversationId)
+  ]);
+  const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(conversationId));
+  const referencedRecords = await driver.runs.loadMany(transaction, {
+    conversationId,
+    runIds: referencedRunIds(messages)
+  });
+  return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
+}
+function loadSnapshot(driver, conversationId) {
+  return driver.transaction((transaction) => snapshotIn(driver, transaction, conversationId), {
+    access: "read"
+  });
+}
+function loadRun(driver, input) {
+  return driver.transaction(async (transaction) => {
+    const [stored, record] = await Promise.all([
+      driver.head.load(transaction, input.conversationId),
+      driver.runs.load(transaction, input)
+    ]);
+    if (!record)
+      return;
+    const parsed = AgentStoredRunSchema2.parse(record);
+    if (parsed.run.conversationId !== input.conversationId || parsed.run.id !== input.runId) {
+      throw new TypeError("Stored run does not match the identity it was loaded by");
     }
-  };
+    const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(input.conversationId));
+    return AgentRunViewSchema2.parse({
+      snapshotVersion: head.version,
+      run: parsed.run,
+      ...parsed.terminalAssistant && { assistant: parsed.terminalAssistant }
+    });
+  }, { access: "read" });
 }
-function branchRun(ids, sourceConversationId, run, settled) {
-  if (run.conversationId !== sourceConversationId)
-    throw new TypeError("Branch run belongs to another conversation");
-  const { ownerId, fencingToken, ...record } = run;
-  return {
-    ...record,
-    id: ids.reference("run", run.id),
-    conversationId: ids.conversationId,
-    inputMessageIds: run.inputMessageIds.map((id) => ids.reference("message", id)),
-    assistantMessageId: ids.reference("message", run.assistantMessageId),
-    ...run.absorbedIntoRunId && {
-      absorbedIntoRunId: ids.reference("run", run.absorbedIntoRunId)
-    },
-    ...run.lastOperation && {
-      lastOperation: {
-        ...run.lastOperation,
-        operationId: ids.reference("operation", run.lastOperation.operationId)
+function listActiveRuns(driver, conversationId) {
+  return driver.transaction(async (transaction) => {
+    const [records, messages] = await Promise.all([
+      driver.runs.listActive(transaction, conversationId),
+      driver.history.load(transaction, conversationId)
+    ]);
+    const runs = records.map((record) => AgentStoredRunSchema2.parse(record).run);
+    for (const run of runs) {
+      if (run.conversationId !== conversationId) {
+        throw new TypeError("Active run belongs to another conversation");
       }
-    },
-    ...!settled && ownerId && { ownerId: ids.define("owner", ownerId) },
-    ...!settled && fencingToken !== undefined && { fencingToken }
-  };
+      if (!isActiveRunState(run.state)) {
+        throw new TypeError("Active run listing returned a terminal run");
+      }
+    }
+    return orderRuns(messages, runs);
+  }, { access: "read" });
 }
-
-// src/agent-runtime/branch-observations.ts
-import { z as z6 } from "zod";
-var Id = z6.string().min(1);
-var Hash2 = z6.string().regex(/^[a-f0-9]{64}$/);
-var State = z6.object({
-  name: Id,
-  version: z6.int().positive(),
-  value: z6.json(),
-  actor: z6.enum(["agent", "human", "system"])
-}).strict();
-var Retry = z6.object({
-  attempt: z6.int().positive(),
-  delayMs: z6.number().nonnegative().optional(),
-  reason: z6.string().optional()
-}).strict();
-var Spill = z6.object({ reference: Id, bytes: z6.int().nonnegative(), sha256: Hash2.optional() }).strict();
-var Schedule = z6.object({
-  id: Id,
-  kind: z6.enum(["at", "after", "every"]).optional(),
-  nextAt: z6.string().nullable().optional(),
-  occurrence: z6.int().nonnegative().optional(),
-  lateByMs: z6.number().nonnegative().optional(),
-  state: z6.string().optional(),
-  message: z6.string().optional(),
-  attempts: z6.int().nonnegative().optional(),
-  retryAt: z6.string().nullable().optional(),
-  terminal: z6.boolean().optional(),
-  skipped: z6.boolean().optional()
-}).strict();
-var Child = z6.object({
-  childConversationId: Id.optional(),
-  parentConversationId: Id.optional(),
-  seedUptoSeq: z6.int().nonnegative().optional(),
-  budget: z6.json().optional(),
-  state: z6.string().optional(),
-  resultReference: Id.optional(),
-  reason: z6.string().optional(),
-  action: z6.enum(["message-sent", "blocking-presented", "blocking-resolved"]).optional(),
-  approvalId: Id.optional(),
-  childApprovalId: Id.optional(),
-  callId: Id.optional(),
-  toolName: Id.optional(),
-  input: z6.json().optional(),
-  batchId: Id.optional(),
-  kind: z6.string().optional(),
-  presentedAt: z6.string().optional(),
-  approved: z6.boolean().optional()
-}).strict();
-var Rejection = z6.object({ approvalId: Id, callId: Id, toolName: Id, reason: z6.string() }).strict();
-function branchObservation(ids, kind, raw) {
-  if (kind.startsWith("durability/")) {
-    const value = kind === "durability/step" ? StepEventPayloadSchema.parse(raw) : kind === "durability/park" ? ParkEventPayloadSchema.parse(raw) : kind === "durability/event" ? DeliveredEventPayloadSchema.parse(raw) : kind === "durability/effect" ? EffectEventPayloadSchema.parse(raw) : undefined;
-    if (!value || canonicalAgentJson2(value) !== canonicalAgentJson2(raw))
-      throw new TypeError("Branch cannot rekey opaque durability payload");
-    if ("encoded" in value)
-      branchOpaqueJson(z6.json().parse(JSON.parse(value.encoded)));
-    return {
-      ...value,
-      runId: ids.reference("run", value.runId),
-      ..."id" in value && { id: ids.define("key", value.id) }
-    };
-  }
-  if (kind === "sandbox/probed")
-    return z6.object({
-      result: AgentSandboxGradeSchema2,
-      required: z6.array(AgentSandboxRestrictionSchema2),
-      missing: z6.array(AgentSandboxRestrictionSchema2)
-    }).strict().parse(raw);
-  if (kind === "state/set") {
-    const value = State.parse(raw);
-    branchOpaqueJson(value.value);
-    return value;
-  }
-  if (kind === "retry/scheduled" || kind === "retry/started")
-    return Retry.parse(raw);
-  if (kind === "spill/created" || kind === "spill/deleted") {
-    const value = Spill.parse(raw);
-    return { ...value, reference: ids.reference("spill", value.reference) };
-  }
-  if (kind.startsWith("schedule/")) {
-    const value = Schedule.parse(raw);
-    return { ...value, id: ids.define("schedule", value.id) };
+function appendEvent(driver, input) {
+  const parsed = AppendAgentStoreEventSchema2.parse(input);
+  return driver.transaction((transaction) => appendEventIn(driver, transaction, parsed));
+}
+async function appendEventIn(driver, transaction, parsed) {
+  if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+    throw new AgentConversationPurgedError2;
   }
-  if (kind.startsWith("child/")) {
-    const value = Child.parse(raw);
-    if (value.budget)
-      branchOpaqueJson(value.budget);
-    if (value.input)
-      branchOpaqueJson(value.input);
-    return {
-      ...value,
-      ...value.childConversationId && {
-        childConversationId: value.childConversationId === ids.sourceConversationId ? ids.conversationId : ids.define("child", value.childConversationId)
-      },
-      ...value.parentConversationId && {
-        parentConversationId: value.parentConversationId === ids.sourceConversationId ? ids.conversationId : ids.define("child", value.parentConversationId)
-      },
-      ...value.resultReference && {
-        resultReference: ids.reference("spill", value.resultReference)
-      },
-      ...value.approvalId && { approvalId: ids.define("approval", value.approvalId) },
-      ...value.childApprovalId && {
-        childApprovalId: ids.define("approval", value.childApprovalId)
-      },
-      ...value.callId && { callId: ids.reference("call", value.callId) },
-      ...value.batchId && { batchId: ids.define("key", value.batchId) }
-    };
+  return driver.events.append(transaction, agentStoreEventDraft(parsed));
+}
+function readEvents(driver, input) {
+  const parsed = ReadAgentStoreEventsSchema2.parse(input);
+  return driver.transaction(async (transaction) => AgentStoreEventPageSchema2.parse(await driver.events.list(transaction, parsed)), { access: "read" });
+}
+
+// src/agent-runtime/store-replay.ts
+async function persistRuntimeReplay(driver, tx, replay) {
+  if (replay.baseline) {
+    const baseline = replay.baseline;
+    for (const record of baseline.runs)
+      await driver.runs.save(tx, record);
+    if (driver.history.restore)
+      await driver.history.restore(tx, {
+        conversationId: baseline.head.conversationId,
+        messages: baseline.messages,
+        compactedMessageIds: baseline.compacted ?? []
+      });
+    else
+      for (const message of baseline.messages)
+        await driver.history.apply(tx, { type: "admit", input: message });
+    for (const receipt of baseline.admissions)
+      await driver.admissions.create(tx, receipt);
   }
-  if (kind === "approval/response-rejected") {
-    const value = Rejection.parse(raw);
-    return {
-      ...value,
-      approvalId: ids.reference("approval", value.approvalId),
-      callId: ids.reference("call", value.callId)
-    };
+  for (const effect of replay.effects) {
+    for (const record of effect.runRecords ?? [])
+      await driver.runs.save(tx, record);
+    if (effect.admissionReceipt)
+      await driver.admissions.create(tx, effect.admissionReceipt);
+    if (effect.seedReceipt)
+      await driver.seeds.create(tx, effect.seedReceipt);
+    for (const mutation of effect.historyMutations ?? [])
+      await driver.history.apply(tx, mutation);
   }
-  throw new TypeError(`Branch cannot rekey opaque event kind ${kind}`);
 }
-var BranchObservationSchema = z6.object({ sourceKind: Id, payload: z6.json() }).strict();
 
-// src/agent-runtime/branch-provider.ts
-import { createHash } from "node:crypto";
-import { z as z7 } from "zod";
-var Hash3 = z7.string().regex(/^[a-f0-9]{64}$/);
-var Text = z7.object({ type: z7.enum(["text", "reasoning"]), text: z7.string() }).strict();
-var Call = z7.object({
-  type: z7.literal("tool-call"),
-  toolCallId: z7.string(),
-  toolName: z7.string(),
-  input: z7.json()
-}).strict();
-var Result = z7.object({
-  type: z7.literal("tool-result"),
-  toolCallId: z7.string(),
-  toolName: z7.string(),
-  output: z7.discriminatedUnion("type", [
-    z7.object({ type: z7.enum(["text", "error-text"]), value: z7.string() }).strict(),
-    z7.object({ type: z7.enum(["json", "error-json"]), value: z7.json() }).strict()
-  ])
-}).strict();
-var Message = z7.object({
-  role: z7.enum(["user", "assistant", "tool"]),
-  content: z7.union([
-    z7.string(),
-    z7.array(z7.union([
-      Text,
-      Call,
-      Result,
-      z7.object({
-        type: z7.literal("tool-approval-request"),
-        approvalId: z7.string(),
-        toolCallId: z7.string(),
-        signature: z7.string().optional(),
-        isAutomatic: z7.boolean().optional()
-      }).strict(),
-      z7.object({
-        type: z7.literal("tool-approval-response"),
-        approvalId: z7.string(),
-        approved: z7.boolean(),
-        reason: z7.string().optional()
-      }).strict(),
-      z7.object({
-        type: z7.literal("file"),
-        data: z7.union([
-          z7.string(),
-          z7.object({
-            binary: z7.literal(true),
-            sha256: Hash3,
-            bytes: z7.int().nonnegative()
-          }).strict()
-        ]),
-        mediaType: z7.string(),
-        filename: z7.string().optional()
-      }).strict(),
-      z7.object({
-        type: z7.literal("image"),
-        image: z7.union([
-          z7.string(),
-          z7.object({
-            binary: z7.literal(true),
-            sha256: Hash3,
-            bytes: z7.int().nonnegative()
-          }).strict()
-        ]),
-        mediaType: z7.string().optional()
-      }).strict()
-    ]))
-  ])
-}).strict();
-var ProviderMessage = z7.object({ sha256: Hash3, message: Message }).strict();
-var ProviderRequest = z7.object({
-  runId: z7.string(),
-  attempt: z7.int().nonnegative(),
-  stepNumber: z7.int().nonnegative(),
-  modelId: z7.string(),
-  instructionsSha256: Hash3,
-  messageShas: z7.array(Hash3),
-  bodySha256: Hash3
-}).strict();
-var ProviderResponse = z7.object({
-  runId: z7.string(),
-  attempt: z7.int().nonnegative(),
-  stepNumber: z7.int().nonnegative(),
-  response: z7.object({ id: z7.string(), provider: z7.string().optional() }).strict()
-}).strict();
-function hash(value) {
-  return createHash("sha256").update(canonicalAgentJson2(value)).digest("hex");
+// src/agent-runtime/store-archive.ts
+function exportConversation(driver, conversationId) {
+  return driver.transaction(async (transaction) => {
+    return exportConversationIn(driver, transaction, conversationId);
+  }, { access: "read" });
 }
-
-class BranchProvider {
-  ids;
-  digests = new Map;
-  constructor(ids) {
-    this.ids = ids;
-  }
-  rekey(kind, raw) {
-    if (kind === "provider/message") {
-      const value = ProviderMessage.parse(raw);
-      if (hash(value.message) !== value.sha256)
-        throw new TypeError("Branch provider message digest is inconsistent");
-      const message = {
-        ...value.message,
-        content: typeof value.message.content === "string" ? value.message.content : value.message.content.map((part) => {
-          if (part.type === "tool-call")
-            return {
-              ...part,
-              toolCallId: this.ids.reference("call", part.toolCallId),
-              input: branchToolJson(this.ids, part.toolName, part.input, false)
-            };
-          if (part.type === "tool-result") {
-            if (part.output.type === "error-json")
-              branchOpaqueJson(part.output.value);
-            return {
-              ...part,
-              toolCallId: this.ids.reference("call", part.toolCallId),
-              output: part.output.type === "json" ? {
-                ...part.output,
-                value: branchToolJson(this.ids, part.toolName, part.output.value, true)
-              } : part.output
-            };
-          }
-          if (part.type === "tool-approval-request")
-            return {
-              type: part.type,
-              approvalId: this.ids.reference("approval", part.approvalId),
-              toolCallId: this.ids.reference("call", part.toolCallId)
-            };
-          if (part.type === "tool-approval-response")
-            return {
-              ...part,
-              approvalId: this.ids.reference("approval", part.approvalId)
-            };
-          return part;
-        })
-      };
-      const sha256 = hash(message);
-      this.digests.set(value.sha256, sha256);
-      return { sha256, message };
+async function importConversation(driver, bytes) {
+  const archive = decodeAgentConversationArchive2(bytes);
+  return driver.transaction(async (transaction) => {
+    const existing = await driver.events.list(transaction, {
+      conversationId: archive.conversationId,
+      limit: 1
+    });
+    if (existing.items.length > 0) {
+      throw new TypeError("Conversation event log must be empty before import");
     }
-    if (kind === "provider/request") {
-      const value = ProviderRequest.parse(raw);
-      const sourceHash = createHash("sha256").update(value.instructionsSha256).update(value.messageShas.join(",")).digest("hex");
-      if (sourceHash !== value.bodySha256)
-        throw new TypeError("Branch provider request digest is inconsistent");
-      const messageShas = value.messageShas.map((sha) => {
-        const target = this.digests.get(sha);
-        if (!target)
-          throw new TypeError("Branch provider request references a missing message");
-        return target;
+    for (const event of archive.events) {
+      const appended = await driver.events.append(transaction, {
+        schemaVersion: event.schemaVersion,
+        eventId: event.eventId,
+        conversationId: event.conversationId,
+        kind: event.kind,
+        occurredAt: event.occurredAt,
+        payload: event.payload,
+        ...event.ignorable && { ignorable: true }
       });
-      return {
-        ...value,
-        runId: this.ids.reference("run", value.runId),
-        messageShas,
-        bodySha256: createHash("sha256").update(value.instructionsSha256).update(messageShas.join(",")).digest("hex")
-      };
+      if (appended.seq !== event.seq) {
+        throw new TypeError("Conversation archive event sequence is not contiguous");
+      }
     }
-    const value = ProviderResponse.parse(raw);
-    return { ...value, runId: this.ids.reference("run", value.runId) };
-  }
+    const snapshotEntry = archive.projections.find((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && entry.archiveType === "runtime-snapshot");
+    if (snapshotEntry && typeof snapshotEntry === "object" && !Array.isArray(snapshotEntry)) {
+      const snapshot = AgentSnapshotSchema2.parse(snapshotEntry.snapshot);
+      if (snapshot.conversationId !== archive.conversationId) {
+        throw new TypeError("Conversation archive snapshot belongs to another conversation");
+      }
+      if (snapshot.version > 0 || snapshot.messages.length > 0 || snapshot.runs.length > 0) {
+        const outcome = await driver.head.compareAndSwap(transaction, {
+          conversationId: snapshot.conversationId,
+          expectedVersion: 0,
+          next: AgentRuntimeHeadSchema2.parse({
+            schemaVersion: 1,
+            conversationId: snapshot.conversationId,
+            version: snapshot.version
+          })
+        });
+        if (outcome.outcome !== "applied") {
+          throw new TypeError("Conversation archive snapshot target is not empty");
+        }
+      }
+      const replay = replayBranchEvents(archive.conversationId, archive.events, snapshot);
+      await persistRuntimeReplay(driver, transaction, replay);
+      for (const run of snapshot.runs) {
+        const terminalAssistant = snapshot.messages.find((message) => message.id === run.assistantMessageId);
+        await driver.runs.save(transaction, AgentStoredRunSchema2.parse({
+          schemaVersion: 1,
+          run,
+          ...terminalAssistant && { terminalAssistant }
+        }));
+      }
+      const restoredIds = new Set((await driver.history.load(transaction, archive.conversationId)).map((message) => message.id));
+      for (const message of snapshot.messages) {
+        if (message.role === "assistant")
+          await driver.history.apply(transaction, { type: "upsert-assistant", message });
+        else if (!restoredIds.has(message.id))
+          await driver.history.apply(transaction, { type: "admit", input: message });
+      }
+    }
+    await driver.archive?.import(transaction, archive);
+    return { conversationId: archive.conversationId, events: archive.events.length };
+  });
 }
-
-// src/agent-runtime/branch-replay.ts
-import { createHash as createHash3 } from "node:crypto";
-import { z as z8 } from "zod";
-
-// src/agent-runtime/store-reducer.ts
-import { createHash as createHash2 } from "node:crypto";
-
-// src/agent-runtime/store-reduce-shared.ts
-function conflict(actualVersion) {
-  return { outcome: "conflict", actualVersion };
-}
-function applied(current, input, effects) {
-  const runs = input.runs ?? current.runs;
-  const messages = input.messages ?? current.messages;
-  return {
-    outcome: "applied",
-    snapshot: AgentSnapshotSchema2.parse({
-      ...current,
-      version: current.version + 1,
-      runs,
-      messages: orderRunMessages(messages, runs)
-    }),
-    ...effects?.runRecords?.length && { runRecords: effects.runRecords },
-    ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
-    ...effects?.seedReceipt && { seedReceipt: effects.seedReceipt },
-    ...effects?.historyMutations?.length && { historyMutations: effects.historyMutations }
-  };
-}
-
-// src/agent-runtime/store-reduce-history.ts
-function reduceAccept(current, input) {
-  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.executionSequence !== undefined || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" && input.input.role !== "tool" || 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 ? AgentRunSchema2.parse({
-    ...coalescedRun,
-    inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
-    revision: coalescedRun.revision + 1,
-    updatedAt: new Date().toISOString()
-  }) : input.run;
-  const admissionReceipt = AgentAdmissionReceiptSchema2.parse({
-    schemaVersion: 1,
-    conversationId: input.input.conversationId,
-    idempotencyKey: input.idempotencyKey,
-    input: input.input,
-    runId: assignedRun.id,
-    assistantMessageId: assignedRun.assistantMessageId
-  });
-  return applied(current, {
-    messages: [...current.messages, input.input],
-    runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
-  }, {
-    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: assignedRun })],
-    admissionReceipt,
-    historyMutations: [{ type: "admit", input: input.input }]
-  });
-}
-function reduceSeed(current, input) {
-  const conversationId = input.conversationId;
-  if (current.conversationId !== conversationId)
-    return { outcome: "not_found" };
-  for (const message of input.inputs) {
-    if (message.conversationId !== conversationId || message.role !== "user" || message.status !== "committed" || message.runId !== undefined) {
-      throw new TypeError("Seeded conversation input must be committed unowned user messages");
-    }
-  }
-  return applied(current, { messages: [...input.inputs, ...current.messages] }, {
-    seedReceipt: AgentSeedReceiptSchema2.parse({
-      schemaVersion: 1,
+async function exportConversationIn(driver, transaction, conversationId) {
+  const events = [];
+  let fromSeq;
+  do {
+    const page = AgentStoreEventPageSchema2.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema2.parse({
       conversationId,
-      seedKey: input.seedKey,
-      messageIds: input.inputs.map((message) => message.id)
-    }),
-    historyMutations: [...input.inputs].reverse().map((message) => ({
-      type: "seed",
-      message
-    }))
-  });
-}
-function reduceCompact(current, input) {
-  if (current.conversationId !== input.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 liveAssistant = current.runs.find((candidate) => isActiveRunState(candidate.state) && replaced.has(candidate.assistantMessageId));
-  if (liveAssistant) {
-    throw new TypeError(`Compaction may not replace the assistant message of run ${liveAssistant.id}, which has not finished`);
-  }
-  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, { messages }, {
-    historyMutations: [
-      {
-        type: "replace-compacted-range",
-        replacedMessageIds: input.replacedMessageIds,
-        summary: input.summary
-      }
-    ]
+      ...fromSeq && { fromSeq },
+      limit: 1e4
+    })));
+    events.push(...page.items);
+    fromSeq = page.nextSeq;
+  } while (fromSeq !== undefined);
+  const durable = await driver.archive?.export(transaction, conversationId) ?? {
+    projections: [],
+    spills: []
+  };
+  const snapshot = await snapshotIn(driver, transaction, conversationId);
+  return encodeAgentConversationArchive2({
+    format: "stitchkit.agent-conversation",
+    formatVersion: 1,
+    conversationId,
+    events,
+    projections: [
+      { archiveType: "runtime-snapshot", snapshot: z5.json().parse(snapshot) },
+      ...durable.projections
+    ],
+    spills: durable.spills
   });
 }
 
-// src/agent-runtime/store-reduce-run.ts
-function reduceAcquire(current, run, input) {
-  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 !== input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
-    return conflict(run.revision);
-  }
-  const next = AgentRunSchema2.parse({
-    ...run,
-    state: "running",
-    executionSequence: run.executionSequence ?? current.version + 1,
-    ownerId: input.ownerId,
-    fencingToken: (run.fencingToken ?? 0) + 1,
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
-  });
-}
-function reduceCheckpoint(current, run, 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 = AgentRunSchema2.parse({
-    ...run,
-    ...input.usage && { usage: input.usage },
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  return applied(current, {
-    runs: replaceRun(current.runs, next),
-    messages: replaceMessage(current.messages, input.assistant)
-  }, {
-    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })],
-    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
-  });
-}
-function reduceOperation(current, run, input) {
-  if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken) {
-    return conflict(run.revision);
-  }
-  const next = AgentRunSchema2.parse({
-    ...run,
-    lastOperation: input.operation,
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  return applied(current, { runs: replaceRun(current.runs, next) }, { runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })] });
-}
-function reduceInterrupt(current, run, input) {
-  if (run.revision !== input.expectedRevision || run.state !== "running") {
-    return conflict(run.revision);
-  }
-  const next = AgentRunSchema2.parse({
-    ...run,
-    state: "interrupt_requested",
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
-  });
-}
-function reduceRecover(current, run, input, retainedAssistant) {
-  if (run.revision !== input.expectedRevision || !isActiveRunState(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 { ownerId: _released, ...carried } = run;
-  const next = AgentRunSchema2.parse({
-    ...carried,
-    state: input.action === "requeue" ? "queued" : "abandoned",
-    revision: run.revision + 1,
-    ...input.action === "abandon" && { terminalReason: "abandoned" },
-    updatedAt: new Date().toISOString()
-  });
-  if (input.action === "abandon") {
-    if (retainedAssistant && (retainedAssistant.id !== run.assistantMessageId || retainedAssistant.conversationId !== run.conversationId || retainedAssistant.runId !== run.id || retainedAssistant.role !== "assistant" || retainedAssistant.status !== "failed"))
-      throw new TypeError("Abandoned assistant does not match its run");
-    const existingAssistant = current.messages.find((message) => message.id === run.assistantMessageId);
-    const assistant = retainedAssistant ?? AgentMessageSchema2.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()
-    });
-    return applied(current, {
-      runs: replaceRun(current.runs, next),
-      messages: replaceMessage(current.messages, assistant)
-    }, {
-      runRecords: [
-        AgentStoredRunSchema2.parse({
-          schemaVersion: 1,
-          run: next,
-          terminalAssistant: assistant
-        })
-      ],
-      historyMutations: [{ type: "upsert-assistant", message: assistant }]
-    });
+// src/agent-runtime/store-branch.ts
+import { createHash as createHash7 } from "node:crypto";
+import { z as z13 } from "zod";
+
+// src/agent-runtime/branch-events.ts
+import { z as z9 } from "zod";
+
+// src/agent-runtime/branch-messages.ts
+import { z as z6 } from "zod";
+function branchOpaqueJson(value) {
+  if (Array.isArray(value))
+    return value.map(branchOpaqueJson);
+  if (value !== null && typeof value === "object") {
+    for (const key of [
+      "reference",
+      "conversationId",
+      "runId",
+      "messageId",
+      "callId",
+      "toolCallId",
+      "approvalId",
+      "operationId",
+      "artifactId"
+    ]) {
+      if (key in value)
+        throw new TypeError(`Branch cannot rekey an opaque payload containing ${key}`);
+    }
+    for (const entry of Object.values(value))
+      branchOpaqueJson(entry);
   }
-  return applied(current, { runs: replaceRun(current.runs, next) }, {
-    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
-  });
+  return value;
 }
-
-// src/agent-runtime/store-reduce-terminal.ts
-function reduceTerminal(current, run, input) {
-  if (input.reason === "absorbed") {
-    throw new TypeError("A run is absorbed by another run, never terminalized as absorbed");
-  }
-  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 !== assistantStatus(input.reason)) {
-    return conflict(run.revision);
-  }
-  if (input.absorb && runStateForTerminalReason2(input.reason) !== "completed") {
-    throw new TypeError("Only a completing run may absorb a queued successor");
+var ArtifactReadSchema = z6.object({
+  reference: z6.string(),
+  offset: z6.int().nonnegative(),
+  maxBytes: z6.int().positive().optional()
+}).strict();
+var ArtifactSearchSchema = z6.object({
+  reference: z6.string(),
+  query: z6.string(),
+  maxMatches: z6.int().positive().optional()
+}).strict();
+var ArtifactReadResultSchema = z6.object({
+  reference: z6.string(),
+  offset: z6.int().nonnegative(),
+  text: z6.string(),
+  bytes: z6.int().nonnegative(),
+  totalBytes: z6.int().nonnegative().optional()
+}).strict();
+var ArtifactSearchResultSchema = z6.object({
+  reference: z6.string(),
+  matches: z6.array(z6.object({ line: z6.int().positive(), text: z6.string() }).strict())
+}).strict();
+function branchToolJson(ids, name, value, output) {
+  if (name === AGENT_CODING_TOOL_NAMES.readOutput || name === AGENT_CODING_TOOL_NAMES.searchOutput) {
+    const parsed = output ? name === AGENT_CODING_TOOL_NAMES.readOutput ? ArtifactReadResultSchema.parse(value) : ArtifactSearchResultSchema.parse(value) : name === AGENT_CODING_TOOL_NAMES.readOutput ? ArtifactReadSchema.parse(value) : ArtifactSearchSchema.parse(value);
+    return { ...parsed, reference: ids.reference("spill", parsed.reference) };
   }
-  const named = new Set((input.absorb ?? []).map((entry) => entry.runId));
-  if (named.size !== (input.absorb ?? []).length || named.has(run.id)) {
-    throw new TypeError("An absorption names each successor once, and never the absorbing run");
+  if (output && name === AGENT_CODING_TOOL_NAMES.runCommand) {
+    const parsed = ShellOutputSchema.parse(value);
+    return {
+      ...parsed,
+      ...parsed.artifact && {
+        artifact: {
+          ...parsed.artifact,
+          reference: ids.reference("spill", parsed.artifact.reference)
+        }
+      }
+    };
   }
-  const absorbable = (input.absorb ?? []).filter((entry) => {
-    const candidate = current.runs.find((item) => item.id === entry.runId);
-    return candidate !== undefined && candidate.id !== run.id && candidate.state === "queued" && candidate.conversationId === run.conversationId && candidate.inputMessageIds.length === entry.inputMessageIds.length && candidate.inputMessageIds.every((id, index) => id === entry.inputMessageIds[index]);
-  });
-  const absorbedIds = new Set(absorbable.flatMap((entry) => entry.inputMessageIds));
-  const next = AgentRunSchema2.parse({
-    ...run,
-    state: runStateForTerminalReason2(input.reason),
-    terminalReason: input.reason,
-    ...input.policyName && { terminalPolicyName: input.policyName },
-    ...input.usage && { usage: input.usage },
-    ...absorbedIds.size > 0 && {
-      inputMessageIds: [
-        ...run.inputMessageIds,
-        ...[...absorbedIds].filter((id) => !run.inputMessageIds.includes(id))
-      ]
-    },
-    revision: run.revision + 1,
-    updatedAt: new Date().toISOString()
-  });
-  const absorbedRuns = absorbable.map((entry) => {
-    const candidate = current.runs.find((item) => item.id === entry.runId);
-    if (!candidate)
-      throw new TypeError("Absorbed run disappeared inside the reducer");
-    return AgentRunSchema2.parse({
-      ...candidate,
-      state: runStateForTerminalReason2("absorbed"),
-      terminalReason: "absorbed",
-      absorbedIntoRunId: next.id,
-      revision: candidate.revision + 1,
-      updatedAt: new Date().toISOString()
-    });
-  });
-  const runs = absorbedRuns.reduce((accumulated, absorbed) => replaceRun(accumulated, absorbed), replaceRun(current.runs, next));
-  return applied(current, {
-    runs,
-    messages: replaceMessage(current.messages, input.assistant)
-  }, {
-    runRecords: [
-      AgentStoredRunSchema2.parse({
-        schemaVersion: 1,
-        run: next,
-        terminalAssistant: input.assistant
-      }),
-      ...absorbedRuns.map((absorbed) => AgentStoredRunSchema2.parse({ schemaVersion: 1, run: absorbed }))
-    ],
-    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
-  });
+  return branchOpaqueJson(value);
 }
-
-// src/agent-runtime/store-reducer.ts
-function transitionRecord(operation, reduced) {
-  if (operation.type === "recover" && operation.input.action === "abandon") {
-    const assistant = reduced?.runRecords?.find((record) => record.run.id === operation.input.runId)?.terminalAssistant;
-    if (assistant)
-      return { ...operation, assistant };
+function branchPart(ids, part) {
+  switch (part.type) {
+    case "file":
+      return { ...part, reference: ids.reference("spill", part.reference) };
+    case "tool-call": {
+      if (part.provider)
+        branchOpaqueJson(part.provider.data);
+      return {
+        ...part,
+        callId: ids.reference("call", part.callId),
+        input: branchToolJson(ids, part.toolName, part.input, false)
+      };
+    }
+    case "tool-result":
+      return {
+        ...part,
+        callId: ids.reference("call", part.callId),
+        ...part.output !== undefined && {
+          output: part.outcome === "success" ? branchToolJson(ids, part.toolName, part.output, true) : branchOpaqueJson(part.output)
+        }
+      };
+    case "tool-approval-request":
+      return {
+        type: part.type,
+        approvalId: ids.reference("approval", part.approvalId),
+        callId: ids.reference("call", part.callId)
+      };
+    case "tool-approval-response":
+      return { ...part, approvalId: ids.reference("approval", part.approvalId) };
+    case "provider":
+      throw new TypeError("Branch cannot rekey an opaque provider part");
+    case "reasoning":
+      if (part.provider)
+        branchOpaqueJson(part.provider.data);
+      return part;
+    default:
+      return part;
   }
-  if (operation.type !== "checkpoint")
-    return operation;
-  const { assistant, ...rest } = operation.input;
-  const body = canonicalAgentJson2(assistant);
+}
+function branchMessage(ids, sourceConversationId, message) {
+  if (message.conversationId !== sourceConversationId)
+    throw new TypeError("Branch message belongs to another conversation");
   return {
-    type: operation.type,
-    input: {
-      ...rest,
-      assistant: {
-        id: assistant.id,
-        status: assistant.status,
-        sha256: createHash2("sha256").update(body).digest("hex"),
-        parts: assistant.parts.length,
-        bytes: Buffer.byteLength(body)
-      }
+    ...message,
+    id: ids.reference("message", message.id),
+    conversationId: ids.conversationId,
+    ...message.runId && { runId: ids.reference("run", message.runId) },
+    parts: message.parts.map((part) => branchPart(ids, part)),
+    ...message.metadata && {
+      metadata: z6.record(z6.string(), z6.json()).parse(branchOpaqueJson(message.metadata))
     }
   };
 }
-function reduceStore(current, operation) {
-  if (operation.type === "accept")
-    return reduceAccept(current, operation.input);
-  if (operation.type === "seed")
-    return reduceSeed(current, operation.input);
-  if (operation.type === "compact")
-    return reduceCompact(current, operation.input);
-  const run = current.runs.find((candidate) => candidate.id === operation.input.runId);
-  if (!run)
-    return { outcome: "not_found" };
-  switch (operation.type) {
-    case "acquire":
-      return reduceAcquire(current, run, operation.input);
-    case "checkpoint":
-      return reduceCheckpoint(current, run, operation.input);
-    case "operation":
-      return reduceOperation(current, run, operation.input);
-    case "interrupt":
-      return reduceInterrupt(current, run, operation.input);
-    case "recover":
-      return reduceRecover(current, run, operation.input, operation.assistant);
-    case "terminal":
-      return reduceTerminal(current, run, operation.input);
+function branchRun(ids, sourceConversationId, run, settled) {
+  if (run.conversationId !== sourceConversationId)
+    throw new TypeError("Branch run belongs to another conversation");
+  const { ownerId, fencingToken, ...record } = run;
+  return {
+    ...record,
+    id: ids.reference("run", run.id),
+    conversationId: ids.conversationId,
+    inputMessageIds: run.inputMessageIds.map((id) => ids.reference("message", id)),
+    assistantMessageId: ids.reference("message", run.assistantMessageId),
+    ...run.absorbedIntoRunId && {
+      absorbedIntoRunId: ids.reference("run", run.absorbedIntoRunId)
+    },
+    ...run.lastOperation && {
+      lastOperation: {
+        ...run.lastOperation,
+        operationId: ids.reference("operation", run.lastOperation.operationId)
+      }
+    },
+    ...!settled && ownerId && { ownerId: ids.define("owner", ownerId) },
+    ...!settled && fencingToken !== undefined && { fencingToken }
+  };
+}
+
+// src/agent-runtime/branch-observations.ts
+import { z as z7 } from "zod";
+var Id = z7.string().min(1);
+var Hash2 = z7.string().regex(/^[a-f0-9]{64}$/);
+var State = z7.object({
+  name: Id,
+  version: z7.int().positive(),
+  value: z7.json(),
+  actor: z7.enum(["agent", "human", "system"])
+}).strict();
+var Retry = z7.object({
+  attempt: z7.int().positive(),
+  delayMs: z7.number().nonnegative().optional(),
+  reason: z7.string().optional()
+}).strict();
+var Spill = z7.object({ reference: Id, bytes: z7.int().nonnegative(), sha256: Hash2.optional() }).strict();
+var Schedule = z7.object({
+  id: Id,
+  kind: z7.enum(["at", "after", "every"]).optional(),
+  nextAt: z7.string().nullable().optional(),
+  occurrence: z7.int().nonnegative().optional(),
+  lateByMs: z7.number().nonnegative().optional(),
+  state: z7.string().optional(),
+  message: z7.string().optional(),
+  attempts: z7.int().nonnegative().optional(),
+  retryAt: z7.string().nullable().optional(),
+  terminal: z7.boolean().optional(),
+  skipped: z7.boolean().optional()
+}).strict();
+var Child = z7.object({
+  childConversationId: Id.optional(),
+  parentConversationId: Id.optional(),
+  seedUptoSeq: z7.int().nonnegative().optional(),
+  budget: z7.json().optional(),
+  state: z7.string().optional(),
+  resultReference: Id.optional(),
+  reason: z7.string().optional(),
+  action: z7.enum(["message-sent", "blocking-presented", "blocking-resolved"]).optional(),
+  approvalId: Id.optional(),
+  childApprovalId: Id.optional(),
+  callId: Id.optional(),
+  toolName: Id.optional(),
+  input: z7.json().optional(),
+  batchId: Id.optional(),
+  kind: z7.string().optional(),
+  presentedAt: z7.string().optional(),
+  approved: z7.boolean().optional()
+}).strict();
+var Rejection = z7.object({ approvalId: Id, callId: Id, toolName: Id, reason: z7.string() }).strict();
+function branchObservation(ids, kind, raw) {
+  if (kind.startsWith("durability/")) {
+    const value = kind === "durability/step" ? StepEventPayloadSchema.parse(raw) : kind === "durability/park" ? ParkEventPayloadSchema.parse(raw) : kind === "durability/event" ? DeliveredEventPayloadSchema.parse(raw) : kind === "durability/effect" ? EffectEventPayloadSchema.parse(raw) : undefined;
+    if (!value || canonicalAgentJson2(value) !== canonicalAgentJson2(raw))
+      throw new TypeError("Branch cannot rekey opaque durability payload");
+    if ("encoded" in value)
+      branchOpaqueJson(z7.json().parse(JSON.parse(value.encoded)));
+    return {
+      ...value,
+      runId: ids.reference("run", value.runId),
+      ..."id" in value && { id: ids.define("key", value.id) }
+    };
+  }
+  if (kind === "sandbox/probed")
+    return z7.object({
+      result: AgentSandboxGradeSchema2,
+      required: z7.array(AgentSandboxRestrictionSchema2),
+      missing: z7.array(AgentSandboxRestrictionSchema2)
+    }).strict().parse(raw);
+  if (kind === "state/set") {
+    const value = State.parse(raw);
+    branchOpaqueJson(value.value);
+    return value;
+  }
+  if (kind === "retry/scheduled" || kind === "retry/started")
+    return Retry.parse(raw);
+  if (kind === "spill/created" || kind === "spill/deleted") {
+    const value = Spill.parse(raw);
+    return { ...value, reference: ids.reference("spill", value.reference) };
+  }
+  if (kind.startsWith("schedule/")) {
+    const value = Schedule.parse(raw);
+    return { ...value, id: ids.define("schedule", value.id) };
+  }
+  if (kind.startsWith("child/")) {
+    const value = Child.parse(raw);
+    if (value.budget)
+      branchOpaqueJson(value.budget);
+    if (value.input)
+      branchOpaqueJson(value.input);
+    return {
+      ...value,
+      ...value.childConversationId && {
+        childConversationId: value.childConversationId === ids.sourceConversationId ? ids.conversationId : ids.define("child", value.childConversationId)
+      },
+      ...value.parentConversationId && {
+        parentConversationId: value.parentConversationId === ids.sourceConversationId ? ids.conversationId : ids.define("child", value.parentConversationId)
+      },
+      ...value.resultReference && {
+        resultReference: ids.reference("spill", value.resultReference)
+      },
+      ...value.approvalId && { approvalId: ids.define("approval", value.approvalId) },
+      ...value.childApprovalId && {
+        childApprovalId: ids.define("approval", value.childApprovalId)
+      },
+      ...value.callId && { callId: ids.reference("call", value.callId) },
+      ...value.batchId && { batchId: ids.define("key", value.batchId) }
+    };
   }
+  if (kind === "approval/response-rejected") {
+    const value = Rejection.parse(raw);
+    return {
+      ...value,
+      approvalId: ids.reference("approval", value.approvalId),
+      callId: ids.reference("call", value.callId)
+    };
+  }
+  throw new TypeError(`Branch cannot rekey opaque event kind ${kind}`);
 }
-function operationConversationId(operation) {
-  return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
-}
+var BranchObservationSchema = z7.object({ sourceKind: Id, payload: z7.json() }).strict();
 
-// src/agent-runtime/branch-replay.ts
-var BranchBaselineSchema = z8.object({
-  migratedAt: z8.iso.datetime({ offset: true }),
-  asOf: z8.iso.datetime({ offset: true }).optional(),
-  head: AgentRuntimeHeadSchema2,
-  messages: z8.array(AgentMessageSchema2),
-  compacted: z8.array(z8.string().min(1)).optional(),
-  runs: z8.array(AgentStoredRunSchema2),
-  admissions: z8.array(AgentAdmissionReceiptSchema2)
-}).strict();
-var CheckpointRecordSchema = z8.object({
-  type: z8.literal("checkpoint"),
-  input: z8.object({
-    conversationId: z8.string().min(1),
-    runId: z8.string().min(1),
-    expectedRevision: z8.int().nonnegative(),
-    ownerId: z8.string().min(1),
-    fencingToken: z8.int().nonnegative().optional(),
-    assistant: z8.object({
-      id: z8.string().min(1),
-      status: z8.literal("streaming"),
-      sha256: z8.string().regex(/^[a-f0-9]{64}$/).optional(),
-      sourceSha256: z8.string().regex(/^[a-f0-9]{64}$/).optional(),
-      parts: z8.int().nonnegative(),
-      bytes: z8.int().nonnegative()
-    }).strict(),
-    usage: AgentUsageSchema2.optional()
-  }).strict()
-}).strict().refine((value) => Boolean(value.input.assistant.sha256) !== Boolean(value.input.assistant.sourceSha256));
-function branchTransition(event) {
-  const checkpoint = CheckpointRecordSchema.safeParse(event.payload);
-  if (!checkpoint.success)
-    return AgentStoreTransitionSchema2.parse(event.payload);
-  const input = checkpoint.data.input;
-  if (canonicalAgentJson2(checkpoint.data) !== canonicalAgentJson2(event.payload))
-    throw new TypeError("Branch checkpoint contains an unknown opaque field");
-  return AgentStoreTransitionSchema2.parse({
-    type: "checkpoint",
-    input: {
-      ...input,
-      assistant: {
-        schemaVersion: 1,
-        id: input.assistant.id,
-        conversationId: input.conversationId,
-        runId: input.runId,
-        role: "assistant",
-        status: "streaming",
-        parts: [],
-        createdAt: event.occurredAt,
-        updatedAt: event.occurredAt
-      }
-    }
-  });
+// src/agent-runtime/branch-provider.ts
+import { createHash as createHash3 } from "node:crypto";
+function hash(value) {
+  return createHash3("sha256").update(canonicalAgentJson2(value)).digest("hex");
 }
-function replayBranchEvents(conversationId, events, retainedSnapshot) {
-  const result = {
-    snapshot: AgentSnapshotSchema2.parse({
-      schemaVersion: 1,
-      conversationId,
-      version: 0,
-      messages: [],
-      runs: []
-    }),
-    effects: [],
-    unresolvedDrafts: new Set,
-    retainedMessages: new Map
-  };
-  for (const event of events) {
-    if (event.kind === "runtime/baseline") {
-      if (event.seq !== 1 || result.snapshot.version !== 0)
-        throw new TypeError("Branch baseline must be the first event");
-      const baseline = BranchBaselineSchema.parse(event.payload);
-      if (baseline.head.conversationId !== conversationId)
-        throw new TypeError("Branch baseline has a foreign conversation");
-      const compacted = new Set(baseline.compacted);
-      snapshotOf(baseline.head, baseline.messages, baseline.runs);
-      const keys = new Set;
-      for (const record of baseline.runs) {
-        if (record.run.inputMessageIds.some((id) => !baseline.messages.some((message) => message.id === id)))
-          throw new TypeError("Branch baseline run references missing input");
-      }
-      for (const admission of baseline.admissions) {
-        const run = baseline.runs.find((record) => record.run.id === admission.runId)?.run;
-        if (keys.has(admission.idempotencyKey) || admission.conversationId !== conversationId || admission.input.conversationId !== conversationId || !run || !run.inputMessageIds.includes(admission.input.id) || run.assistantMessageId !== admission.assistantMessageId || !baseline.messages.some((message) => message.id === admission.input.id && canonicalAgentJson2(message) === canonicalAgentJson2(admission.input)))
-          throw new TypeError("Branch baseline admission is inconsistent");
-        keys.add(admission.idempotencyKey);
-      }
-      if (compacted.size !== (baseline.compacted?.length ?? 0) || [...compacted].some((id) => !baseline.messages.some((m) => m.id === id)))
-        throw new TypeError("Branch baseline compacted identities are inconsistent");
-      result.snapshot = snapshotOf(baseline.head, baseline.messages.filter((m) => !compacted.has(m.id)), baseline.runs);
-      result.baseline = baseline;
-      continue;
-    }
-    if (event.kind === "runtime/branched") {
-      const receipt = AgentConversationBranchReceiptSchema2.parse(event.payload);
-      if (receipt.conversationId !== conversationId)
-        throw new TypeError("Branch receipt has a foreign conversation");
-      result.snapshot = {
-        ...result.snapshot,
-        runs: result.snapshot.runs.map(({ ownerId: _owner, fencingToken: _fence, ...run }) => run)
+function checkFileData(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return;
+  if (value.type === "reference" && "reference" in value)
+    branchOpaqueJson(value.reference);
+  else if (!("type" in value) && value.binary !== true)
+    branchOpaqueJson(value);
+}
+
+class BranchProvider {
+  ids;
+  digests = new Map;
+  constructor(ids) {
+    this.ids = ids;
+  }
+  rekey(kind, raw) {
+    if (kind === "provider/message") {
+      const value = ProviderJournalMessageSchema.parse(raw);
+      if (hash(value.message) !== value.sha256)
+        throw new TypeError("Branch provider message digest is inconsistent");
+      if (value.message.providerOptions)
+        branchOpaqueJson(value.message.providerOptions);
+      const message = {
+        ...value.message,
+        content: typeof value.message.content === "string" ? value.message.content : value.message.content.map((part) => {
+          if ("providerOptions" in part && part.providerOptions)
+            branchOpaqueJson(part.providerOptions);
+          if (part.type === "file" || part.type === "reasoning-file")
+            checkFileData(part.data);
+          if (part.type === "image")
+            checkFileData(part.image);
+          if (part.type === "tool-call")
+            return {
+              ...part,
+              toolCallId: this.ids.reference("call", part.toolCallId),
+              input: branchToolJson(this.ids, part.toolName, part.input, false)
+            };
+          if (part.type === "tool-result") {
+            if ("providerOptions" in part.output && part.output.providerOptions)
+              branchOpaqueJson(part.output.providerOptions);
+            if (part.output.type === "error-json")
+              branchOpaqueJson(part.output.value);
+            if (part.output.type === "content")
+              for (const item of part.output.value) {
+                if (item.providerOptions)
+                  branchOpaqueJson(item.providerOptions);
+                if (item.type === "file")
+                  checkFileData(item.data);
+                if ("providerReference" in item)
+                  branchOpaqueJson(item.providerReference);
+                if ("fileId" in item && typeof item.fileId !== "string")
+                  branchOpaqueJson(item.fileId);
+              }
+            return {
+              ...part,
+              toolCallId: this.ids.reference("call", part.toolCallId),
+              output: part.output.type === "json" ? {
+                ...part.output,
+                value: branchToolJson(this.ids, part.toolName, part.output.value, true)
+              } : part.output
+            };
+          }
+          if (part.type === "tool-approval-request")
+            return {
+              type: part.type,
+              approvalId: this.ids.reference("approval", part.approvalId),
+              toolCallId: this.ids.reference("call", part.toolCallId),
+              ...part.reason !== undefined && { reason: part.reason }
+            };
+          if (part.type === "tool-approval-response")
+            return {
+              ...part,
+              approvalId: this.ids.reference("approval", part.approvalId)
+            };
+          return part;
+        })
       };
-      continue;
-    }
-    if (event.kind !== "runtime/transition")
-      continue;
-    let operation = branchTransition(event);
-    if (operation.type === "checkpoint" && retainedSnapshot) {
-      const record = CheckpointRecordSchema.safeParse(event.payload);
-      const assistantId = operation.input.assistant.id;
-      const retained = retainedSnapshot.messages.find((message) => message.id === assistantId);
-      if (record.success && retained && record.data.input.assistant.sha256 === createHash3("sha256").update(canonicalAgentJson2(retained)).digest("hex")) {
-        operation = { ...operation, input: { ...operation.input, assistant: retained } };
-        result.retainedMessages.set(event.eventId, retained);
-      }
-    }
-    if (operation.type === "recover" && operation.input.action === "abandon" && !operation.assistant && retainedSnapshot) {
-      const runId = operation.input.runId;
-      const run = result.snapshot.runs.find((run) => run.id === runId);
-      const retained = retainedSnapshot.messages.find((message) => message.id === run?.assistantMessageId && message.runId === runId && message.role === "assistant" && message.status === "failed");
-      if (retained)
-        operation = { ...operation, assistant: retained };
+      const sha256 = hash(message);
+      this.digests.set(value.sha256, sha256);
+      return { sha256, message };
     }
-    if (operation.type === "recover" && operation.input.action === "abandon" && !operation.assistant)
-      throw new TypeError("Branch archive has no exact retained abandoned assistant");
-    const inputConversation = operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
-    if (inputConversation !== conversationId)
-      throw new TypeError("Branch transition has a foreign conversation");
-    const reduced = reduceStore(result.snapshot, operation);
-    if (reduced.outcome !== "applied")
-      throw new TypeError(`Branch transition at sequence ${event.seq} is inconsistent: ${reduced.outcome}`);
-    const runRecords = reduced.runRecords?.map((record) => ({
-      ...record,
-      run: { ...record.run, updatedAt: event.occurredAt }
-    }));
-    result.snapshot = {
-      ...reduced.snapshot,
-      runs: reduced.snapshot.runs.map((run) => runRecords?.find((record) => record.run.id === run.id)?.run ?? run)
-    };
-    const { snapshot: _snapshot, outcome: _outcome, ...effects } = reduced;
-    result.effects.push({ ...effects, ...runRecords && { runRecords } });
-    if (operation.type === "recover" && operation.input.action === "abandon") {
-      const runId = operation.input.runId;
-      const assistant = reduced.runRecords?.find((record) => record.run.id === runId)?.terminalAssistant;
-      if (assistant)
-        result.retainedMessages.set(event.eventId, assistant);
-      if (operation.assistant)
-        result.unresolvedDrafts.delete(runId);
+    if (kind === "provider/request") {
+      const value = ProviderJournalRequestSchema.parse(raw);
+      const sourceHash = createHash3("sha256").update(value.instructionsSha256).update(value.messageShas.join(",")).digest("hex");
+      if (sourceHash !== value.bodySha256)
+        throw new TypeError("Branch provider request digest is inconsistent");
+      const messageShas = value.messageShas.map((sha) => {
+        const target = this.digests.get(sha);
+        if (!target)
+          throw new TypeError("Branch provider request references a missing message");
+        return target;
+      });
+      return {
+        ...value,
+        runId: this.ids.reference("run", value.runId),
+        messageShas,
+        bodySha256: createHash3("sha256").update(value.instructionsSha256).update(messageShas.join(",")).digest("hex")
+      };
     }
-    if (operation.type === "checkpoint" && CheckpointRecordSchema.safeParse(event.payload).success)
-      result.unresolvedDrafts.add(operation.input.runId);
-    if (operation.type === "terminal")
-      result.unresolvedDrafts.delete(operation.input.runId);
+    const value = ProviderJournalResponseSchema.parse(raw);
+    return { ...value, runId: this.ids.reference("run", value.runId) };
   }
-  return result;
 }
 
 // src/agent-runtime/branch-transitions.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 function rekeyBranchTransition(ids, source, operation) {
   const message = (value) => branchMessage(ids, source, value);
   const input = operation.input;
@@ -1495,11 +1443,11 @@ function rekeyBranchTransition(ids, source, operation) {
   }
 }
 function branchJson(value) {
-  return z9.json().parse(value);
+  return z8.json().parse(value);
 }
 
 // src/agent-runtime/branch-events.ts
-var Hash4 = z10.string().regex(/^[a-f0-9]{64}$/);
+var Hash3 = z9.string().regex(/^[a-f0-9]{64}$/);
 function rekeyBranchEvents(ids, source, events, retainedMessages = new Map) {
   const hydrated = events.map((event) => {
     const assistant = retainedMessages.get(event.eventId);
@@ -1546,14 +1494,14 @@ function rekeyBranchEvent(ids, source, event, provider) {
   if (event.kind === "runtime/transition") {
     const operation = branchTransition(event);
     const rekeyed = rekeyBranchTransition(ids, source, operation);
-    const raw = z10.object({
-      type: z10.string(),
-      input: z10.object({
-        assistant: z10.object({
-          sha256: Hash4.optional(),
-          sourceSha256: Hash4.optional(),
-          bytes: z10.int(),
-          parts: z10.int()
+    const raw = z9.object({
+      type: z9.string(),
+      input: z9.object({
+        assistant: z9.object({
+          sha256: Hash3.optional(),
+          sourceSha256: Hash3.optional(),
+          bytes: z9.int(),
+          parts: z9.int()
         }).passthrough()
       }).passthrough()
     }).passthrough().safeParse(event.payload);
@@ -1713,6 +1661,16 @@ class BranchIdentities {
 import { createHash as createHash6 } from "node:crypto";
 import { z as z12 } from "zod";
 
+// src/agent-runtime/archive-projection.ts
+import { z as z10 } from "zod";
+var ArchiveProjectionSchema = z10.object({
+  name: z10.string(),
+  version: z10.int().positive(),
+  uptoSeq: z10.int().nonnegative(),
+  value: z10.json(),
+  updatedAt: z10.string()
+}).strict();
+
 // src/agent-runtime/archive-spill.ts
 import { createHash as createHash5 } from "node:crypto";
 import { z as z11 } from "zod";
@@ -1780,12 +1738,21 @@ function prepareBranchSource(bytes, source) {
     if (event.seq !== index + 1)
       throw new TypeError("Branch source event sequence is incomplete");
   }
-  const projections = archive.projections.map((value) => SnapshotProjection.parse(value));
+  const projections = archive.projections.map((value) => z12.union([SnapshotProjection, ArchiveProjectionSchema]).parse(value));
   if (projections.some((value, index) => canonicalAgentJson2(value) !== canonicalAgentJson2(archive.projections[index])))
     throw new TypeError("Branch archive snapshot contains an unknown opaque field");
-  if (projections.length !== 1)
-    throw new TypeError("Branch archive requires exactly one runtime snapshot and no opaque projections");
-  const expected = projections[0]?.snapshot;
+  const snapshots = projections.filter((value) => ("archiveType" in value));
+  if (snapshots.length !== 1)
+    throw new TypeError("Branch archive requires exactly one runtime snapshot");
+  const names = new Set;
+  for (const projection of projections) {
+    if (!("name" in projection))
+      continue;
+    if (names.has(projection.name) || projection.uptoSeq > archive.events.length)
+      throw new TypeError("Branch companion projection has an inconsistent checkpoint");
+    names.add(projection.name);
+  }
+  const expected = snapshots[0]?.snapshot;
   if (!expected || expected.conversationId !== archive.conversationId)
     throw new TypeError("Branch archive has a foreign snapshot");
   const allSpills = archive.spills.map((value) => ArchiveSpillSchema.parse(value));
@@ -1834,44 +1801,6 @@ function prepareBranchSource(bytes, source) {
 }
 
 // src/agent-runtime/store-branch.ts
-async function persistReplay(driver, tx, replay) {
-  if (replay.baseline) {
-    const baseline = replay.baseline;
-    for (const record of baseline.runs)
-      await driver.runs.save(tx, record);
-    if (driver.history.restore)
-      await driver.history.restore(tx, {
-        conversationId: baseline.head.conversationId,
-        messages: baseline.messages,
-        compactedMessageIds: baseline.compacted ?? []
-      });
-    else
-      for (const message of baseline.messages)
-        await driver.history.apply(tx, { type: "admit", input: message });
-    for (const receipt of baseline.admissions)
-      await driver.admissions.create(tx, receipt);
-  }
-  for (const effect of replay.effects) {
-    for (const record of effect.runRecords ?? [])
-      await driver.runs.save(tx, record);
-    if (effect.admissionReceipt)
-      await driver.admissions.create(tx, effect.admissionReceipt);
-    if (effect.seedReceipt)
-      await driver.seeds.create(tx, effect.seedReceipt);
-    for (const mutation of effect.historyMutations ?? [])
-      await driver.history.apply(tx, mutation);
-  }
-  for (const run of replay.snapshot.runs) {
-    const stored = await driver.runs.load(tx, {
-      conversationId: run.conversationId,
-      runId: run.id
-    });
-    if (!stored)
-      throw new TypeError("Branch lost a normalized terminal record");
-    const { ownerId: _owner, fencingToken: _fence, ...settled } = stored.run;
-    await driver.runs.save(tx, { ...stored, run: settled });
-  }
-}
 async function destinationEvents(driver, tx, conversationId) {
   const events = [];
   let fromSeq;
@@ -1957,7 +1886,17 @@ async function branchConversation(driver, raw) {
     });
     if (cas.outcome !== "applied")
       throw new TypeError("Branch destination changed");
-    await persistReplay(driver, tx, replay);
+    await persistRuntimeReplay(driver, tx, replay);
+    for (const run of replay.snapshot.runs) {
+      const stored = await driver.runs.load(tx, {
+        conversationId: run.conversationId,
+        runId: run.id
+      });
+      if (!stored)
+        throw new TypeError("Branch lost a normalized terminal record");
+      const { ownerId: _owner, fencingToken: _fence, ...settled } = stored.run;
+      await driver.runs.save(tx, { ...stored, run: settled });
+    }
     for (const event of events) {
       const appended = await driver.events.append(tx, event);
       if (appended.seq !== event.seq)
@@ -2277,4 +2216,4 @@ function createAgentRuntimeStore2(driver) {
   };
 }
 
-export { BranchAgentConversationInputSchema2, AgentConversationBranchReceiptSchema2, AgentConversationBranchResultSchema2, AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, replaceMessage, appendEventIn, ArchiveSpillSchema, createAgentRuntimeStore2 };
+export { BranchAgentConversationInputSchema2, AgentConversationBranchReceiptSchema2, AgentConversationBranchResultSchema2, AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, replaceMessage, appendEventIn, ArchiveProjectionSchema, ArchiveSpillSchema, createAgentRuntimeStore2 };