stitchkit 0.110.1 → 0.110.3

package/dist/index-j1cwtyk1.js

@@ -0,0 +1,2269 @@
+import {
+  AgentCodingToolAuthorizationSchema2,
+  ShellOutputSchema,
+  AgentSandboxRestrictionSchema2,
+  AgentSandboxGradeSchema2,
+  AGENT_CODING_TOOL_NAMES
+} from "./index-bm180f2d.js";
+import {
+  AgentRecordIdSchema2,
+  AgentRecordVersionSchema2,
+  AgentTimestampSchema2,
+  AgentMessageSchema2,
+  runStateForTerminalReason2,
+  AgentRunSchema2,
+  AgentSnapshotSchema2
+} from "./index-8kzct1d6.js";
+import {
+  AppendAgentStoreEventSchema2,
+  ReadAgentStoreEventsSchema2,
+  AgentStoreEventPageSchema2,
+  AgentRunViewSchema2,
+  AcceptInputAndAssignRunSchema2,
+  AcquireAgentRunSchema2,
+  CheckpointRunAssistantSchema2,
+  RecordRunOperationSchema2,
+  CommitRunTerminalSchema2,
+  RequestRunInterruptSchema2,
+  RecoverAgentRunSchema2,
+  ReplaceCompactedRangeSchema2,
+  SeedConversationInputSchema2,
+  AgentRecoverablePageSchema2,
+  AgentStoreTransitionSchema2,
+  AgentStoreCheckpointRecordSchema,
+  agentStoreEventDraft,
+  canonicalAgentJson2,
+  encodeAgentConversationArchive2,
+  decodeAgentConversationArchive2,
+  assistantStatus
+} from "./index-4fgg1507.js";
+import {
+  StepEventPayloadSchema,
+  ParkEventPayloadSchema,
+  DeliveredEventPayloadSchema,
+  EffectEventPayloadSchema
+} from "./index-snef22zr.js";
+
+// src/agent-runtime/branch-contract.ts
+import { z } from "zod";
+var Hash = z.string().regex(/^[a-f0-9]{64}$/);
+var BranchAgentConversationInputSchema2 = z.object({
+  requestKey: AgentRecordIdSchema2,
+  destinationConversationId: AgentRecordIdSchema2,
+  source: z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("conversation"),
+      conversationId: AgentRecordIdSchema2,
+      throughRunId: AgentRecordIdSchema2.optional()
+    }).strict(),
+    z.object({
+      kind: z.literal("archive"),
+      bytes: z.custom((value) => value instanceof Uint8Array)
+    }).strict()
+  ]),
+  artifactAuthorization: AgentCodingToolAuthorizationSchema2.optional()
+}).strict();
+var AgentConversationBranchReceiptSchema2 = z.object({
+  schemaVersion: z.literal(1),
+  requestKey: AgentRecordIdSchema2,
+  fingerprint: Hash,
+  conversationId: AgentRecordIdSchema2,
+  sourceConversationId: AgentRecordIdSchema2,
+  sourceKind: z.enum(["conversation", "archive"]),
+  throughRunId: AgentRecordIdSchema2.optional(),
+  sourceSeq: z.int().nonnegative(),
+  sourceVersion: z.int().nonnegative(),
+  sourceDigest: Hash,
+  createdAt: AgentTimestampSchema2
+}).strict();
+var AgentConversationBranchResultSchema2 = z.object({
+  outcome: z.enum(["created", "duplicate"]),
+  receipt: AgentConversationBranchReceiptSchema2
+}).strict();
+
+// src/agent-runtime/purge.ts
+import { z as z2 } from "zod";
+var AgentConversationPurgeInputSchema2 = z2.strictObject({
+  conversationId: AgentRecordIdSchema2,
+  expectedVersion: AgentRecordVersionSchema2.optional()
+});
+var AgentConversationPurgeResultSchema2 = z2.discriminatedUnion("outcome", [
+  z2.strictObject({ outcome: z2.literal("purged") }),
+  z2.strictObject({ outcome: z2.literal("already_purged") }),
+  z2.strictObject({ outcome: z2.literal("unsupported") }),
+  z2.strictObject({
+    outcome: z2.literal("active"),
+    runIds: z2.array(AgentRecordIdSchema2).min(1)
+  }),
+  z2.strictObject({ outcome: z2.literal("conflict"), actualVersion: AgentRecordVersionSchema2 })
+]);
+
+class AgentConversationPurgedError2 extends Error {
+  constructor() {
+    super("Agent conversation has been purged; use a new conversation ID");
+    this.name = "AgentConversationPurgedError";
+  }
+}
+async function purgeAgentConversation2(store, input) {
+  const parsed = AgentConversationPurgeInputSchema2.parse(input);
+  if (!store.purgeConversation)
+    return { outcome: "unsupported" };
+  return AgentConversationPurgeResultSchema2.parse(await store.purgeConversation(parsed));
+}
+
+// src/agent-runtime/store-driver-contract.ts
+import { z as z3 } from "zod";
+var AgentRuntimeHeadSchema2 = z3.object({
+  schemaVersion: z3.literal(1),
+  conversationId: AgentRecordIdSchema2,
+  version: AgentRecordVersionSchema2
+});
+var AgentStoredRunSchema2 = z3.object({
+  schemaVersion: z3.literal(1),
+  run: AgentRunSchema2,
+  terminalAssistant: AgentMessageSchema2.optional()
+});
+var AgentAdmissionReceiptSchema2 = z3.object({
+  schemaVersion: z3.literal(1),
+  conversationId: AgentRecordIdSchema2,
+  idempotencyKey: z3.string().min(1),
+  input: AgentMessageSchema2,
+  runId: AgentRecordIdSchema2,
+  assistantMessageId: AgentRecordIdSchema2
+});
+var AgentSeedReceiptSchema2 = z3.object({
+  schemaVersion: z3.literal(1),
+  conversationId: AgentRecordIdSchema2,
+  seedKey: z3.string().min(1),
+  messageIds: z3.array(AgentRecordIdSchema2).min(1)
+});
+var AgentHistoryMutationSchema2 = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("admit"), input: AgentMessageSchema2 }),
+  z3.object({
+    type: z3.literal("upsert-assistant"),
+    message: AgentMessageSchema2
+  }),
+  z3.object({
+    type: z3.literal("replace-compacted-range"),
+    replacedMessageIds: z3.array(AgentRecordIdSchema2).min(1),
+    summary: AgentMessageSchema2
+  }),
+  z3.object({
+    type: z3.literal("seed"),
+    message: AgentMessageSchema2
+  })
+]);
+var ACTIVE_AGENT_RUN_STATES2 = [
+  "queued",
+  "running",
+  "interrupt_requested"
+];
+function isActiveRunState(state) {
+  return ACTIVE_AGENT_RUN_STATES2.includes(state);
+}
+function emptyHead(conversationId) {
+  return AgentRuntimeHeadSchema2.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: 0
+  });
+}
+
+// src/agent-runtime/store-create.ts
+import { z as z16 } 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;
+  messages.forEach((message, index) => {
+    if (!positions.has(message.id))
+      positions.set(message.id, index);
+  });
+  return (run) => {
+    let earliest = Number.MAX_SAFE_INTEGER;
+    for (const id of [...run.inputMessageIds, run.assistantMessageId]) {
+      const position = positions.get(id);
+      if (position !== undefined && position < earliest)
+        earliest = position;
+    }
+    return earliest;
+  };
+}
+function orderRuns(messages, runs) {
+  const positionOf = historyPositions(messages);
+  const fallback = (left, right) => left.createdAt.localeCompare(right.createdAt) || positionOf(left) - positionOf(right) || left.id.localeCompare(right.id);
+  return [...runs].sort((left, right) => {
+    if (left.executionSequence !== undefined && right.executionSequence !== undefined && left.executionSequence !== right.executionSequence) {
+      return left.executionSequence - right.executionSequence;
+    }
+    const leftStarted = left.executionSequence !== undefined || left.state !== "queued";
+    const rightStarted = right.executionSequence !== undefined || right.state !== "queued";
+    if (leftStarted !== rightStarted)
+      return leftStarted ? -1 : 1;
+    if (!leftStarted && !rightStarted) {
+      const priority = Number(right.queuePriority !== undefined) - Number(left.queuePriority !== undefined);
+      if (priority !== 0)
+        return priority;
+    }
+    return fallback(left, right);
+  });
+}
+function orderRunMessages(messages, runs) {
+  const byId = new Map(messages.map((message) => [message.id, message]));
+  const ownedIds = new Set(runs.flatMap((run) => [...run.inputMessageIds, run.assistantMessageId]));
+  const orderedOwned = runs.flatMap((run) => [...run.inputMessageIds, run.assistantMessageId].flatMap((id) => {
+    const message = byId.get(id);
+    return message ? [message] : [];
+  }));
+  let ownedIndex = 0;
+  return messages.map((message) => {
+    if (!ownedIds.has(message.id))
+      return message;
+    const ordered = orderedOwned[ownedIndex];
+    if (!ordered)
+      throw new TypeError("Stored agent history lost a run-owned message");
+    ownedIndex += 1;
+    return ordered;
+  });
+}
+function snapshotOf(head, messages, records) {
+  validateSnapshot(head, messages, records);
+  const runs = orderRuns(messages, records.map((record) => record.run));
+  return AgentSnapshotSchema2.parse({
+    schemaVersion: 1,
+    conversationId: head.conversationId,
+    version: head.version,
+    messages: orderRunMessages(messages, runs),
+    runs
+  });
+}
+function validateSnapshot(head, messages, records) {
+  const runIds = new Set;
+  const assistantIds = new Set;
+  const messageIds = new Set;
+  for (const record of records) {
+    const run = record.run;
+    if (run.conversationId !== head.conversationId || runIds.has(run.id) || assistantIds.has(run.assistantMessageId)) {
+      throw new TypeError("Stored agent runs contain inconsistent identities");
+    }
+    if (record.terminalAssistant && (record.terminalAssistant.id !== run.assistantMessageId || record.terminalAssistant.conversationId !== run.conversationId || record.terminalAssistant.runId !== run.id || record.terminalAssistant.role !== "assistant" || run.terminalReason === undefined)) {
+      throw new TypeError("Retained terminal assistant does not match its run");
+    }
+    runIds.add(run.id);
+    assistantIds.add(run.assistantMessageId);
+  }
+  for (const message of messages) {
+    if (message.conversationId !== head.conversationId || messageIds.has(message.id)) {
+      throw new TypeError("Stored agent history contains inconsistent message identities");
+    }
+    messageIds.add(message.id);
+    if (assistantIds.has(message.id) && message.runId === undefined) {
+      throw new TypeError("Stored history occupies a reserved assistant identity");
+    }
+    if (message.runId !== undefined) {
+      const run = records.find((candidate) => candidate.run.id === message.runId)?.run;
+      if (!run || message.role !== "assistant" || run.assistantMessageId !== message.id) {
+        throw new TypeError("Stored assistant history does not match its reserved run identity");
+      }
+    }
+  }
+}
+function replaceRun(runs, next) {
+  return runs.map((run) => run.id === next.id ? next : run);
+}
+function replaceMessage(messages, next) {
+  return messages.some((message) => message.id === next.id) ? messages.map((message) => message.id === next.id ? next : message) : [...messages, next];
+}
+function mergeRunRecords(...groups) {
+  const records = new Map;
+  for (const group of groups) {
+    for (const rawRecord of group) {
+      const record = AgentStoredRunSchema2.parse(rawRecord);
+      const previous = records.get(record.run.id);
+      if (previous && previous.run.assistantMessageId !== record.run.assistantMessageId) {
+        throw new TypeError("Stored agent run identity changed across normalized records");
+      }
+      records.set(record.run.id, record);
+    }
+  }
+  return [...records.values()];
+}
+function referencedRunIds(messages) {
+  return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
+}
+
+// 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,
+      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
+      }
+    ]
+  });
+}
+
+// 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 }]
+    });
+  }
+  return applied(current, { runs: replaceRun(current.runs, next) }, {
+    runRecords: [AgentStoredRunSchema2.parse({ schemaVersion: 1, run: next })]
+  });
+}
+
+// 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 }))
+    ],
+    historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
+  });
+}
+
+// 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)
+      }
+    }
+  });
+}
+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 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();
+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
+      }
+    }
+  });
+}
+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)
+      };
+      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;
+}
+
+// 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 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");
+      }
+    }
+    return orderRuns(messages, runs);
+  }, { access: "read" });
+}
+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;
+  }
+  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);
+  }
+  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);
+  }
+}
+
+// src/agent-runtime/store-archive.ts
+function exportConversation(driver, conversationId) {
+  return driver.transaction(async (transaction) => {
+    return exportConversationIn(driver, transaction, conversationId);
+  }, { access: "read" });
+}
+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");
+        }
+      }
+      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 };
+  });
+}
+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: z5.json().parse(snapshot) },
+      ...durable.projections
+    ],
+    spills: durable.spills
+  });
+}
+
+// src/agent-runtime/store-branch.ts
+import { createHash as createHash7 } from "node:crypto";
+import { z as z14 } from "zod";
+
+// src/agent-runtime/branch-events.ts
+import { z as z10 } 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 value;
+}
+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) };
+  }
+  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)
+        }
+      }
+    };
+  }
+  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)
+      };
+    }
+    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)
+        throw new TypeError("Branch cannot rekey opaque reasoning provider metadata");
+      return part;
+    default:
+      return part;
+  }
+}
+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: z6.record(z6.string(), z6.json()).parse(branchOpaqueJson(message.metadata))
+    }
+  };
+}
+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}`);
+}
+var BranchObservationSchema = z7.object({ sourceKind: Id, payload: z7.json() }).strict();
+
+// src/agent-runtime/branch-provider.ts
+import { createHash as createHash3 } from "node:crypto";
+import { z as z8 } from "zod";
+var Hash3 = z8.string().regex(/^[a-f0-9]{64}$/);
+var Text = z8.object({ type: z8.enum(["text", "reasoning"]), text: z8.string() }).strict();
+var Call = z8.object({
+  type: z8.literal("tool-call"),
+  toolCallId: z8.string(),
+  toolName: z8.string(),
+  input: z8.json()
+}).strict();
+var Result = z8.object({
+  type: z8.literal("tool-result"),
+  toolCallId: z8.string(),
+  toolName: z8.string(),
+  output: z8.discriminatedUnion("type", [
+    z8.object({ type: z8.enum(["text", "error-text"]), value: z8.string() }).strict(),
+    z8.object({ type: z8.enum(["json", "error-json"]), value: z8.json() }).strict()
+  ])
+}).strict();
+var Message = z8.object({
+  role: z8.enum(["user", "assistant", "tool"]),
+  content: z8.union([
+    z8.string(),
+    z8.array(z8.union([
+      Text,
+      Call,
+      Result,
+      z8.object({
+        type: z8.literal("tool-approval-request"),
+        approvalId: z8.string(),
+        toolCallId: z8.string(),
+        signature: z8.string().optional(),
+        isAutomatic: z8.boolean().optional()
+      }).strict(),
+      z8.object({
+        type: z8.literal("tool-approval-response"),
+        approvalId: z8.string(),
+        approved: z8.boolean(),
+        reason: z8.string().optional()
+      }).strict(),
+      z8.object({
+        type: z8.literal("file"),
+        data: z8.union([
+          z8.string(),
+          z8.object({
+            binary: z8.literal(true),
+            sha256: Hash3,
+            bytes: z8.int().nonnegative()
+          }).strict()
+        ]),
+        mediaType: z8.string(),
+        filename: z8.string().optional()
+      }).strict(),
+      z8.object({
+        type: z8.literal("image"),
+        image: z8.union([
+          z8.string(),
+          z8.object({
+            binary: z8.literal(true),
+            sha256: Hash3,
+            bytes: z8.int().nonnegative()
+          }).strict()
+        ]),
+        mediaType: z8.string().optional()
+      }).strict()
+    ]))
+  ])
+}).strict();
+var ProviderMessage = z8.object({ sha256: Hash3, message: Message }).strict();
+var ProviderRequest = z8.object({
+  runId: z8.string(),
+  attempt: z8.int().nonnegative(),
+  stepNumber: z8.int().nonnegative(),
+  modelId: z8.string(),
+  instructionsSha256: Hash3,
+  messageShas: z8.array(Hash3),
+  bodySha256: Hash3
+}).strict();
+var ProviderResponse = z8.object({
+  runId: z8.string(),
+  attempt: z8.int().nonnegative(),
+  stepNumber: z8.int().nonnegative(),
+  response: z8.object({ id: z8.string(), provider: z8.string().optional() }).strict()
+}).strict();
+function hash(value) {
+  return createHash3("sha256").update(canonicalAgentJson2(value)).digest("hex");
+}
+
+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 };
+    }
+    if (kind === "provider/request") {
+      const value = ProviderRequest.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")
+      };
+    }
+    const value = ProviderResponse.parse(raw);
+    return { ...value, runId: this.ids.reference("run", value.runId) };
+  }
+}
+
+// src/agent-runtime/branch-transitions.ts
+import { z as z9 } from "zod";
+function rekeyBranchTransition(ids, source, operation) {
+  const message = (value) => branchMessage(ids, source, value);
+  const input = operation.input;
+  switch (operation.type) {
+    case "accept":
+      return {
+        type: operation.type,
+        input: {
+          ...operation.input,
+          idempotencyKey: ids.define("key", operation.input.idempotencyKey),
+          input: message(operation.input.input),
+          run: branchRun(ids, source, operation.input.run, false),
+          ...operation.input.coalesceIntoRunId && {
+            coalesceIntoRunId: ids.reference("run", operation.input.coalesceIntoRunId)
+          }
+        }
+      };
+    case "seed":
+      return {
+        type: operation.type,
+        input: {
+          ...operation.input,
+          conversationId: ids.conversationId,
+          seedKey: ids.define("key", operation.input.seedKey),
+          inputs: operation.input.inputs.map(message)
+        }
+      };
+    case "compact":
+      return {
+        type: operation.type,
+        input: {
+          ...operation.input,
+          conversationId: ids.conversationId,
+          replacedMessageIds: operation.input.replacedMessageIds.map((id) => ids.reference("message", id)),
+          summary: message(operation.input.summary)
+        }
+      };
+    default: {
+      if (!("runId" in input))
+        throw new TypeError("Branch transition has no run identity");
+      const common = {
+        ...input,
+        conversationId: ids.conversationId,
+        runId: ids.reference("run", input.runId),
+        ..."ownerId" in input && { ownerId: ids.define("owner", input.ownerId) }
+      };
+      return AgentStoreTransitionSchema2.parse({
+        type: operation.type,
+        ...operation.type === "recover" && operation.assistant && { assistant: message(operation.assistant) },
+        input: {
+          ...common,
+          ...operation.type === "checkpoint" || operation.type === "terminal" ? { assistant: message(operation.input.assistant) } : {},
+          ...operation.type === "operation" && {
+            operation: {
+              ...operation.input.operation,
+              operationId: ids.reference("operation", operation.input.operation.operationId)
+            }
+          },
+          ...operation.type === "terminal" && operation.input.absorb && {
+            absorb: operation.input.absorb.map((entry) => ({
+              runId: ids.reference("run", entry.runId),
+              inputMessageIds: entry.inputMessageIds.map((id) => ids.reference("message", id))
+            }))
+          }
+        }
+      });
+    }
+  }
+}
+function branchJson(value) {
+  return z9.json().parse(value);
+}
+
+// src/agent-runtime/branch-events.ts
+var Hash4 = z10.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);
+    if (!assistant)
+      return event;
+    ids.collectMessage(assistant);
+    const operation = event.kind === "runtime/transition" ? branchTransition(event) : undefined;
+    if (operation?.type === "recover" && operation.input.action === "abandon" && !operation.assistant)
+      return { ...event, payload: branchJson({ ...operation, assistant }) };
+    return event;
+  });
+  for (const event of hydrated)
+    collectBranchEvent(ids, event);
+  for (const assistant of hydrated.flatMap((event) => retainedMessages.has(event.eventId) ? [retainedMessages.get(event.eventId)] : [])) {
+    if (assistant)
+      branchMessage(ids, source, assistant);
+  }
+  const provider = new BranchProvider(ids);
+  return hydrated.map((event) => rekeyBranchEvent(ids, source, event, provider));
+}
+function collectBranchEvent(ids, event) {
+  ids.define("event", event.eventId);
+  if (event.schemaVersion !== 1)
+    throw new TypeError("Branch requires a supported event version");
+  if (event.kind === "runtime/transition")
+    ids.collectOperation(branchTransition(event));
+  if (event.kind === "runtime/baseline") {
+    const baseline = BranchBaselineSchema.parse(event.payload);
+    if (canonicalAgentJson2(baseline) !== canonicalAgentJson2(event.payload))
+      throw new TypeError("Branch baseline contains an unknown opaque field");
+    for (const record of baseline.runs)
+      ids.collectRun(record.run);
+    for (const message of baseline.messages)
+      ids.collectMessage(message);
+  }
+}
+function rekeyBranchEvent(ids, source, event, provider) {
+  const envelope = {
+    ...event,
+    eventId: ids.reference("event", event.eventId),
+    conversationId: ids.conversationId
+  };
+  const message = (value) => branchMessage(ids, source, value);
+  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()
+        }).passthrough()
+      }).passthrough()
+    }).passthrough().safeParse(event.payload);
+    if (operation.type === "checkpoint" && raw.success && rekeyed.type === "checkpoint") {
+      const draft = raw.data.input.assistant;
+      return {
+        ...envelope,
+        payload: branchJson({
+          type: "checkpoint",
+          input: {
+            ...rekeyed.input,
+            assistant: {
+              id: rekeyed.input.assistant.id,
+              status: "streaming",
+              sourceSha256: draft.sha256 ?? draft.sourceSha256,
+              parts: draft.parts,
+              bytes: draft.bytes
+            }
+          }
+        })
+      };
+    }
+    if (canonicalAgentJson2(operation) !== canonicalAgentJson2(event.payload))
+      throw new TypeError("Branch transition contains an unknown opaque field");
+    return { ...envelope, payload: branchJson(rekeyed) };
+  }
+  if (event.kind === "runtime/baseline") {
+    const baseline = BranchBaselineSchema.parse(event.payload);
+    return {
+      ...envelope,
+      payload: branchJson({
+        ...baseline,
+        head: { ...baseline.head, conversationId: ids.conversationId },
+        messages: baseline.messages.map(message),
+        ...baseline.compacted && {
+          compacted: baseline.compacted.map((id) => ids.reference("message", id))
+        },
+        runs: baseline.runs.map((record) => ({
+          ...record,
+          run: branchRun(ids, source, record.run, false),
+          ...record.terminalAssistant && {
+            terminalAssistant: message(record.terminalAssistant)
+          }
+        })),
+        admissions: baseline.admissions.map((receipt) => ({
+          ...receipt,
+          conversationId: ids.conversationId,
+          idempotencyKey: ids.define("key", receipt.idempotencyKey),
+          input: message(receipt.input),
+          runId: ids.reference("run", receipt.runId),
+          assistantMessageId: ids.reference("message", receipt.assistantMessageId)
+        }))
+      })
+    };
+  }
+  if (event.kind === "runtime/branched") {
+    const receipt = AgentConversationBranchReceiptSchema2.parse(event.payload);
+    return {
+      ...envelope,
+      payload: branchJson({
+        ...receipt,
+        conversationId: ids.conversationId,
+        requestKey: ids.define("key", receipt.requestKey)
+      })
+    };
+  }
+  if (event.kind === "provider/message" || event.kind === "provider/request" || event.kind === "provider/response")
+    return { ...envelope, payload: branchJson(provider.rekey(event.kind, event.payload)) };
+  const observation = event.kind === "runtime/branch-observation" ? BranchObservationSchema.parse(event.payload) : { sourceKind: event.kind, payload: event.payload };
+  return {
+    ...envelope,
+    kind: "runtime/branch-observation",
+    payload: branchJson({
+      sourceKind: observation.sourceKind,
+      payload: branchObservation(ids, observation.sourceKind, observation.payload)
+    })
+  };
+}
+
+// src/agent-runtime/branch-identities.ts
+import { createHash as createHash4 } from "node:crypto";
+
+class BranchIdentities {
+  conversationId;
+  requestKey;
+  sourceConversationId;
+  definitions = new Map;
+  references = new Map;
+  constructor(conversationId, requestKey, sourceConversationId) {
+    this.conversationId = conversationId;
+    this.requestKey = requestKey;
+    this.sourceConversationId = sourceConversationId;
+  }
+  define(kind, source) {
+    const values = this.definitions.get(kind) ?? new Map;
+    const target = values.get(source) ?? createHash4("sha256").update(JSON.stringify([this.conversationId, this.requestKey, kind, source])).digest("hex");
+    values.set(source, target);
+    this.definitions.set(kind, values);
+    return target;
+  }
+  reference(kind, source) {
+    const target = this.definitions.get(kind)?.get(source);
+    if (!target)
+      throw new TypeError(`Branch contains a foreign or missing ${kind} reference`);
+    const referenced = this.references.get(kind) ?? new Set;
+    referenced.add(source);
+    this.references.set(kind, referenced);
+    return target;
+  }
+  referenced(kind) {
+    return this.references.get(kind) ?? new Set;
+  }
+  collectMessage(message) {
+    this.define("message", message.id);
+    for (const part of message.parts) {
+      if (part.type === "tool-call")
+        this.define("call", part.callId);
+      if (part.type === "tool-approval-request")
+        this.define("approval", part.approvalId);
+    }
+  }
+  collectRun(run) {
+    this.define("run", run.id);
+    this.define("message", run.assistantMessageId);
+    if (run.lastOperation)
+      this.define("operation", run.lastOperation.operationId);
+  }
+  collectOperation(operation) {
+    switch (operation.type) {
+      case "accept":
+        this.collectRun(operation.input.run);
+        this.collectMessage(operation.input.input);
+        break;
+      case "checkpoint":
+      case "terminal":
+        this.collectMessage(operation.input.assistant);
+        break;
+      case "recover":
+        if (operation.assistant)
+          this.collectMessage(operation.assistant);
+        break;
+      case "compact":
+        this.collectMessage(operation.input.summary);
+        break;
+      case "seed":
+        for (const message of operation.input.inputs)
+          this.collectMessage(message);
+        break;
+      case "operation":
+        this.define("operation", operation.input.operation.operationId);
+        break;
+    }
+  }
+}
+
+// src/agent-runtime/branch-source.ts
+import { createHash as createHash6 } from "node:crypto";
+import { z as z13 } from "zod";
+
+// src/agent-runtime/archive-projection.ts
+import { z as z11 } from "zod";
+var ArchiveProjectionSchema = z11.object({
+  name: z11.string(),
+  version: z11.int().positive(),
+  uptoSeq: z11.int().nonnegative(),
+  value: z11.json(),
+  updatedAt: z11.string()
+}).strict();
+
+// src/agent-runtime/archive-spill.ts
+import { createHash as createHash5 } from "node:crypto";
+import { z as z12 } from "zod";
+var ArchiveSpillSchema = z12.object({
+  reference: z12.string().min(1),
+  runId: z12.string().min(1).optional(),
+  toolCallId: z12.string().min(1).optional(),
+  mediaType: z12.string().min(1),
+  bytes: z12.int().nonnegative(),
+  sha256: z12.string().regex(/^[a-f0-9]{64}$/),
+  createdAt: z12.iso.datetime({ offset: true }),
+  expiresAt: z12.iso.datetime({ offset: true }).optional(),
+  authorization: AgentCodingToolAuthorizationSchema2.optional(),
+  base64: z12.string()
+}).strict().superRefine((spill, ctx) => {
+  const bytes = Buffer.from(spill.base64, "base64");
+  if (bytes.toString("base64") !== spill.base64 || bytes.byteLength !== spill.bytes || createHash5("sha256").update(bytes).digest("hex") !== spill.sha256) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Conversation archive spill bytes or digest are inconsistent"
+    });
+  }
+});
+
+// src/agent-runtime/branch-source.ts
+var SnapshotProjection = z13.object({ archiveType: z13.literal("runtime-snapshot"), snapshot: AgentSnapshotSchema2 }).strict();
+function branchHash(value) {
+  return createHash6("sha256").update(canonicalAgentJson2(value)).digest("hex");
+}
+function visibleSnapshot(snapshot) {
+  const referenced = new Set(snapshot.messages.flatMap((message) => message.runId ? [message.runId] : []));
+  return {
+    ...snapshot,
+    runs: snapshot.runs.filter((run) => referenced.has(run.id) || isActiveRunState(run.state)).map(({ updatedAt: _time, ...run }) => run).sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+function boundary(events, throughRunId) {
+  if (!throughRunId)
+    return events.length;
+  for (const event of events) {
+    if (event.kind !== "runtime/transition")
+      continue;
+    const candidate = z13.object({
+      type: z13.string(),
+      input: z13.object({
+        runId: z13.string().optional(),
+        reason: z13.string().optional(),
+        action: z13.string().optional(),
+        absorb: z13.array(z13.object({ runId: z13.string() })).optional()
+      })
+    }).safeParse(event.payload);
+    if (!candidate.success)
+      continue;
+    const { type, input } = candidate.data;
+    if (type === "terminal" && (input.runId === throughRunId || input.absorb?.some((entry) => entry.runId === throughRunId)) || type === "recover" && input.action === "abandon" && input.runId === throughRunId)
+      return event.seq;
+  }
+  throw new TypeError("Branch boundary run has no exact settled event");
+}
+function prepareBranchSource(bytes, source) {
+  const archive = decodeAgentConversationArchive2(bytes);
+  if (source.kind === "conversation" && source.conversationId !== archive.conversationId)
+    throw new TypeError("Branch source identity changed");
+  for (const [index, event] of archive.events.entries()) {
+    if (event.seq !== index + 1)
+      throw new TypeError("Branch source event sequence is incomplete");
+  }
+  const projections = archive.projections.map((value) => z13.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");
+  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));
+  if (new Set(allSpills.map((spill) => spill.reference)).size !== allSpills.length)
+    throw new TypeError("Branch archive has duplicate spill identities");
+  const full = replayBranchEvents(archive.conversationId, archive.events, expected);
+  const validationIds = new BranchIdentities("branch-validation", "branch-validation", archive.conversationId);
+  for (const spill of allSpills)
+    validationIds.define("spill", spill.reference);
+  rekeyBranchEvents(validationIds, archive.conversationId, archive.events, full.retainedMessages);
+  for (const spill of allSpills) {
+    if (spill.runId)
+      validationIds.reference("run", spill.runId);
+    if (spill.toolCallId)
+      validationIds.reference("call", spill.toolCallId);
+  }
+  if (canonicalAgentJson2(visibleSnapshot(full.snapshot)) !== canonicalAgentJson2(visibleSnapshot(expected)))
+    throw new TypeError("Branch archive snapshot disagrees with its event log");
+  const seq = boundary(archive.events, source.kind === "conversation" ? source.throughRunId : undefined);
+  const events = archive.events.slice(0, seq);
+  const replay = seq === archive.events.length ? full : replayBranchEvents(archive.conversationId, events, expected);
+  if (replay.snapshot.runs.some((run) => isActiveRunState(run.state)))
+    throw new TypeError("Branch boundary is not settled");
+  if (replay.unresolvedDrafts.size > 0)
+    throw new TypeError("Branch boundary has no full terminal content for a hashed draft");
+  const selectedIds = new BranchIdentities("branch-validation", "branch-validation", archive.conversationId);
+  for (const spill of allSpills)
+    selectedIds.define("spill", spill.reference);
+  rekeyBranchEvents(selectedIds, archive.conversationId, events, replay.retainedMessages);
+  const references = selectedIds.referenced("spill");
+  const spills = allSpills.filter((spill) => references.has(spill.reference));
+  if (spills.length !== references.size)
+    throw new TypeError("Branch source is missing a referenced spill");
+  return {
+    conversationId: archive.conversationId,
+    events,
+    spills,
+    replay,
+    digest: branchHash({
+      conversationId: archive.conversationId,
+      events,
+      spills,
+      snapshot: replay.snapshot
+    })
+  };
+}
+
+// src/agent-runtime/store-branch.ts
+async function destinationEvents(driver, tx, conversationId) {
+  const events = [];
+  let fromSeq;
+  do {
+    const page = await driver.events.list(tx, { conversationId, fromSeq, limit: 1e4 });
+    events.push(...page.items);
+    fromSeq = page.nextSeq;
+  } while (fromSeq !== undefined);
+  return events;
+}
+async function branchConversation(driver, raw) {
+  const parsed = BranchAgentConversationInputSchema2.parse(raw);
+  const input = {
+    ...parsed,
+    source: parsed.source.kind === "archive" ? { ...parsed.source, bytes: Uint8Array.from(parsed.source.bytes) } : parsed.source
+  };
+  const fingerprint = branchHash({
+    ...input,
+    source: input.source.kind === "archive" ? {
+      kind: "archive",
+      digest: createHash7("sha256").update(input.source.bytes).digest("hex")
+    } : input.source
+  });
+  return driver.transaction(async (tx) => {
+    if (await driver.conversations?.isPurged(tx, input.destinationConversationId))
+      throw new AgentConversationPurgedError2;
+    const existing = await destinationEvents(driver, tx, input.destinationConversationId);
+    const previous = existing.filter((event) => event.kind === "runtime/branched").at(-1);
+    if (previous) {
+      const receipt = AgentConversationBranchReceiptSchema2.parse(previous.payload);
+      if (receipt.requestKey === input.requestKey && receipt.fingerprint === fingerprint && receipt.conversationId === input.destinationConversationId)
+        return { outcome: "duplicate", receipt };
+      throw new TypeError("Branch request conflicts with the destination receipt");
+    }
+    if (driver.conversations?.isEmpty && !await driver.conversations.isEmpty(tx, input.destinationConversationId) || existing.length > 0 || await driver.head.load(tx, input.destinationConversationId) || (await driver.history.load(tx, input.destinationConversationId)).length > 0)
+      throw new TypeError("Branch destination must be empty");
+    if (input.source.kind === "conversation" && await driver.conversations?.isPurged(tx, input.source.conversationId))
+      throw new AgentConversationPurgedError2;
+    if (input.source.kind === "conversation" && !await driver.head.load(tx, input.source.conversationId) && (await driver.events.list(tx, { conversationId: input.source.conversationId, limit: 1 })).items.length === 0)
+      throw new TypeError("Branch source conversation was not found");
+    const bytes = input.source.kind === "archive" ? input.source.bytes : await exportConversationIn(driver, tx, input.source.conversationId);
+    const source = prepareBranchSource(bytes, input.source);
+    if (source.conversationId === input.destinationConversationId)
+      throw new TypeError("Branch requires a new conversation identity");
+    if (source.spills.length > 0 && (!input.artifactAuthorization || !driver.archive))
+      throw new TypeError("Branch spills require an archive adapter and fresh destination artifact authorization");
+    const ids = new BranchIdentities(input.destinationConversationId, input.requestKey, source.conversationId);
+    for (const spill of source.spills)
+      ids.define("spill", spill.reference);
+    const events = rekeyBranchEvents(ids, source.conversationId, source.events, source.replay.retainedMessages);
+    const replay = replayBranchEvents(input.destinationConversationId, events);
+    if (replay.baseline?.compacted?.length && !driver.history.restore)
+      throw new TypeError("Branch baseline requires inactive history restoration support");
+    const spills = source.spills.map(({ authorization: _sourceAuthority, ...spill }) => ({
+      ...spill,
+      reference: ids.reference("spill", spill.reference),
+      ...spill.runId && { runId: ids.reference("run", spill.runId) },
+      ...spill.toolCallId && { toolCallId: ids.reference("call", spill.toolCallId) },
+      authorization: input.artifactAuthorization
+    }));
+    const receipt = AgentConversationBranchReceiptSchema2.parse({
+      schemaVersion: 1,
+      requestKey: input.requestKey,
+      fingerprint,
+      conversationId: input.destinationConversationId,
+      sourceConversationId: source.conversationId,
+      sourceKind: input.source.kind,
+      ...input.source.kind === "conversation" && input.source.throughRunId && { throughRunId: input.source.throughRunId },
+      sourceSeq: source.events.at(-1)?.seq ?? 0,
+      sourceVersion: source.replay.snapshot.version,
+      sourceDigest: source.digest,
+      createdAt: new Date().toISOString()
+    });
+    const next = {
+      schemaVersion: 1,
+      conversationId: input.destinationConversationId,
+      version: replay.snapshot.version
+    };
+    const cas = await driver.head.compareAndSwap(tx, {
+      conversationId: input.destinationConversationId,
+      expectedVersion: 0,
+      next
+    });
+    if (cas.outcome !== "applied")
+      throw new TypeError("Branch destination changed");
+    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)
+        throw new TypeError("Branch event sequence changed");
+    }
+    await driver.archive?.import(tx, {
+      format: "stitchkit.agent-conversation",
+      formatVersion: 1,
+      conversationId: input.destinationConversationId,
+      events: [],
+      projections: [],
+      spills: z14.array(z14.json()).parse(spills)
+    });
+    await driver.events.append(tx, agentStoreEventDraft({
+      conversationId: input.destinationConversationId,
+      kind: "runtime/branched",
+      payload: z14.json().parse(receipt)
+    }));
+    return { outcome: "created", receipt };
+  });
+}
+
+// src/agent-runtime/store-event-once.ts
+import { createHash as createHash8 } from "node:crypto";
+function eventOnceId(conversationId, kind, key) {
+  if (!key)
+    throw new TypeError("Event admission key must not be empty");
+  return createHash8("sha256").update(JSON.stringify([conversationId, kind, key])).digest("hex");
+}
+async function findEvent(driver, transaction, conversationId, eventId) {
+  if (driver.events.find)
+    return driver.events.find(transaction, { conversationId, eventId });
+  let fromSeq;
+  do {
+    const page = await driver.events.list(transaction, {
+      conversationId,
+      fromSeq,
+      limit: 1e4
+    });
+    const found = page.items.find((event) => event.eventId === eventId);
+    if (found)
+      return found;
+    fromSeq = page.nextSeq;
+  } while (fromSeq !== undefined);
+  return;
+}
+function appendEventOnce(driver, input, key) {
+  const parsed = AppendAgentStoreEventSchema2.parse(input);
+  const eventId = eventOnceId(parsed.conversationId, parsed.kind, key);
+  return driver.transaction(async (transaction) => {
+    if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
+      throw new AgentConversationPurgedError2;
+    }
+    const previous = await findEvent(driver, transaction, parsed.conversationId, eventId);
+    if (previous)
+      return { outcome: "duplicate", event: previous };
+    const event = await driver.events.append(transaction, {
+      ...agentStoreEventDraft(parsed),
+      eventId
+    });
+    return { outcome: "applied", event };
+  });
+}
+function findEventOnce(driver, input) {
+  const eventId = eventOnceId(input.conversationId, input.kind, input.key);
+  return driver.transaction((transaction) => findEvent(driver, transaction, input.conversationId, eventId), { access: "read" });
+}
+
+// src/agent-runtime/store-mutate.ts
+import { z as z15 } from "zod";
+function validateAdmissionReceipt(receipt, record, conversationId) {
+  const input = receipt.input;
+  const run = record.run;
+  if (receipt.conversationId !== conversationId || input.conversationId !== conversationId || input.role !== "user" || input.status !== "committed" || input.runId !== undefined || receipt.runId !== run.id || receipt.assistantMessageId !== run.assistantMessageId || !run.inputMessageIds.includes(input.id)) {
+    throw new TypeError("Admission receipt does not match its canonical run assignment");
+  }
+}
+async function readForMutation(driver, transaction, operation) {
+  const conversationId = operationConversationId(operation);
+  if (await driver.conversations?.isPurged(transaction, conversationId)) {
+    throw new AgentConversationPurgedError2;
+  }
+  const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" || operation.type === "seed" ? undefined : operation.input.runId;
+  const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
+    driver.head.load(transaction, conversationId),
+    driver.history.load(transaction, conversationId),
+    driver.runs.listActive(transaction, conversationId),
+    operationRunId ? driver.runs.load(transaction, { conversationId, runId: operationRunId }) : undefined,
+    operation.type === "accept" ? driver.admissions.load(transaction, {
+      conversationId,
+      idempotencyKey: operation.input.idempotencyKey
+    }) : undefined
+  ]);
+  const head = AgentRuntimeHeadSchema2.parse(stored ?? emptyHead(conversationId));
+  const referencedRecords = await driver.runs.loadMany(transaction, {
+    conversationId,
+    runIds: referencedRunIds(messages)
+  });
+  const records = mergeRunRecords(activeRecords, referencedRecords, operationRecord ? [operationRecord] : []);
+  const current = snapshotOf(head, messages, records);
+  return { conversationId, head, messages, records, current, duplicateReceipt };
+}
+async function settledSeed(driver, transaction, read, input) {
+  const { conversationId, current } = read;
+  const existing = await driver.seeds.load(transaction, {
+    conversationId,
+    seedKey: input.seedKey
+  });
+  if (existing)
+    return { outcome: "applied", snapshot: current };
+  let collisions = 0;
+  for (const message of input.inputs) {
+    if (current.messages.some((candidate) => candidate.id === message.id) || driver.history.hasMessage && await driver.history.hasMessage(transaction, {
+      conversationId,
+      messageId: message.id
+    }))
+      collisions++;
+  }
+  if (collisions > 0 && collisions < input.inputs.length) {
+    throw new TypeError("Partial instruction seed collision: restore the complete seed before retrying");
+  }
+  if (collisions > 0) {
+    await driver.seeds.create(transaction, AgentSeedReceiptSchema2.parse({
+      schemaVersion: 1,
+      conversationId,
+      seedKey: input.seedKey,
+      messageIds: input.inputs.map((message) => message.id)
+    }));
+    return { outcome: "applied", snapshot: current };
+  }
+  return;
+}
+async function duplicateAdmission(driver, transaction, read, duplicateReceipt) {
+  const { conversationId, head, messages, records } = read;
+  const duplicateRecord = await driver.runs.load(transaction, {
+    conversationId,
+    runId: duplicateReceipt.runId
+  });
+  if (!duplicateRecord) {
+    throw new TypeError("Admission receipt points to a missing canonical run");
+  }
+  validateAdmissionReceipt(duplicateReceipt, duplicateRecord, conversationId);
+  const answering = duplicateRecord.run.absorbedIntoRunId ? await driver.runs.load(transaction, {
+    conversationId,
+    runId: duplicateRecord.run.absorbedIntoRunId
+  }) : undefined;
+  if (duplicateRecord.run.absorbedIntoRunId && !answering) {
+    throw new TypeError("Absorbed run points to a missing absorbing run");
+  }
+  const canonical = answering ?? duplicateRecord;
+  return {
+    outcome: "duplicate",
+    input: duplicateReceipt.input,
+    inputMessageId: duplicateReceipt.input.id,
+    runId: canonical.run.id,
+    assistantMessageId: canonical.run.assistantMessageId,
+    run: canonical.run,
+    ...canonical.terminalAssistant && {
+      assistant: canonical.terminalAssistant
+    },
+    snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord], answering ? [answering] : []))
+  };
+}
+async function assertAdmissionIdentitiesFree(driver, transaction, conversationId, input) {
+  const inputCollision = await driver.admissions.loadByInputMessageId(transaction, {
+    conversationId,
+    inputMessageId: input.input.id
+  });
+  if (inputCollision) {
+    throw new TypeError("Input message identity is already assigned to an admission");
+  }
+  if (!input.coalesceIntoRunId) {
+    const [runCollision, assistantCollision] = await Promise.all([
+      driver.runs.load(transaction, {
+        conversationId,
+        runId: input.run.id
+      }),
+      driver.runs.loadByAssistantMessageId(transaction, {
+        conversationId,
+        assistantMessageId: input.run.assistantMessageId
+      })
+    ]);
+    if (runCollision || assistantCollision) {
+      throw new TypeError("Queued run identities are already reserved");
+    }
+  }
+}
+async function persistApplied(driver, transaction, read, operation, reduced) {
+  const { conversationId, current } = read;
+  const nextHead = AgentRuntimeHeadSchema2.parse({
+    schemaVersion: 1,
+    conversationId,
+    version: reduced.snapshot.version
+  });
+  const outcome = await driver.head.compareAndSwap(transaction, {
+    conversationId,
+    expectedVersion: current.version,
+    next: nextHead
+  });
+  if (outcome.outcome === "conflict")
+    return conflict(outcome.actualVersion);
+  for (const record of reduced.runRecords ?? []) {
+    await driver.runs.save(transaction, record);
+  }
+  if (reduced.admissionReceipt) {
+    await driver.admissions.create(transaction, reduced.admissionReceipt);
+  }
+  if (reduced.seedReceipt) {
+    await driver.seeds.create(transaction, reduced.seedReceipt);
+  }
+  for (const mutation of reduced.historyMutations ?? []) {
+    await driver.history.apply(transaction, mutation);
+  }
+  await driver.events.append(transaction, agentStoreEventDraft({
+    conversationId,
+    kind: "runtime/transition",
+    payload: z15.json().parse(transitionRecord(operation, reduced))
+  }));
+  return { outcome: "applied", snapshot: reduced.snapshot };
+}
+function mutateStore(driver, operation) {
+  return driver.transaction(async (transaction) => {
+    const read = await readForMutation(driver, transaction, operation);
+    if (operation.type === "seed") {
+      const settled = await settledSeed(driver, transaction, read, operation.input);
+      if (settled)
+        return settled;
+    }
+    if (read.duplicateReceipt) {
+      return duplicateAdmission(driver, transaction, read, read.duplicateReceipt);
+    }
+    if (operation.type === "accept") {
+      await assertAdmissionIdentitiesFree(driver, transaction, read.conversationId, operation.input);
+    }
+    const reduced = reduceStore(read.current, operation);
+    if (reduced.outcome !== "applied")
+      return reduced;
+    return persistApplied(driver, transaction, read, operation, reduced);
+  });
+}
+
+// src/agent-runtime/store-purge.ts
+function createStoreConversationPurge(driver, conversations) {
+  return async (input) => {
+    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema2.parse(input);
+    return driver.transaction(async (transaction) => {
+      if (await conversations.isPurged(transaction, conversationId)) {
+        return { outcome: "already_purged" };
+      }
+      const head = await driver.head.load(transaction, conversationId);
+      const actualVersion = head?.version ?? 0;
+      if (expectedVersion !== undefined && expectedVersion !== actualVersion) {
+        return { outcome: "conflict", actualVersion };
+      }
+      const active = await driver.runs.listActive(transaction, conversationId);
+      if (active.length > 0) {
+        return { outcome: "active", runIds: active.map((record) => record.run.id) };
+      }
+      await conversations.remove(transaction, conversationId);
+      return { outcome: "purged" };
+    });
+  };
+}
+
+// src/agent-runtime/store-create.ts
+var AgentRecoverableScanInputSchema = z16.object({
+  cursor: z16.string().min(1).optional(),
+  limit: z16.number().int().min(1).max(1000)
+});
+function createAgentRuntimeStore2(driver) {
+  const mutate = (operation) => mutateStore(driver, operation);
+  return {
+    branchConversation: (input) => branchConversation(driver, input),
+    loadSnapshot: (conversationId) => loadSnapshot(driver, conversationId),
+    loadRun: (input) => loadRun(driver, input),
+    listActiveRuns: (conversationId) => listActiveRuns(driver, conversationId),
+    appendEventOnce: (input, key) => appendEventOnce(driver, input, key),
+    findEventOnce: (input) => findEventOnce(driver, input),
+    appendEvent: (input) => appendEvent(driver, input),
+    readEvents: (input) => readEvents(driver, input),
+    exportConversation: (conversationId) => exportConversation(driver, conversationId),
+    importConversation: (bytes) => importConversation(driver, bytes),
+    ...driver.conversations && {
+      purgeConversation: createStoreConversationPurge(driver, driver.conversations)
+    },
+    acceptInputAndAssignRun: (input) => mutate({
+      type: "accept",
+      input: AcceptInputAndAssignRunSchema2.parse(input)
+    }),
+    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema2.parse(input) }),
+    checkpointRunAssistant: (input) => mutate({
+      type: "checkpoint",
+      input: CheckpointRunAssistantSchema2.parse(input)
+    }),
+    recordRunOperation: (input) => mutate({
+      type: "operation",
+      input: RecordRunOperationSchema2.parse(input)
+    }),
+    requestRunInterrupt: (input) => mutate({
+      type: "interrupt",
+      input: RequestRunInterruptSchema2.parse(input)
+    }),
+    recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema2.parse(input) }),
+    commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema2.parse(input) }),
+    replaceCompactedRange: (input) => mutate({
+      type: "compact",
+      input: ReplaceCompactedRangeSchema2.parse(input)
+    }),
+    seedConversationInput: (input) => mutate({
+      type: "seed",
+      input: SeedConversationInputSchema2.parse(input)
+    }),
+    async scanRecoverable(input) {
+      const parsed = AgentRecoverableScanInputSchema.parse(input);
+      return AgentRecoverablePageSchema2.parse(await driver.scanRecoverable(parsed));
+    }
+  };
+}
+
+export { BranchAgentConversationInputSchema2, AgentConversationBranchReceiptSchema2, AgentConversationBranchResultSchema2, AgentConversationPurgeInputSchema2, AgentConversationPurgeResultSchema2, AgentConversationPurgedError2, purgeAgentConversation2, AgentRuntimeHeadSchema2, AgentStoredRunSchema2, AgentAdmissionReceiptSchema2, AgentSeedReceiptSchema2, AgentHistoryMutationSchema2, ACTIVE_AGENT_RUN_STATES2, isActiveRunState, replaceMessage, appendEventIn, ArchiveProjectionSchema, ArchiveSpillSchema, createAgentRuntimeStore2 };