stitchkit 0.93.0 → 0.94.1

package/dist/index-hrbajay7.js

@@ -1,1196 +0,0 @@
-import {
-  AcceptInputAndAssignRunSchema,
-  AcquireAgentRunSchema,
-  AgentRecoverablePageSchema,
-  AgentRunViewSchema,
-  AgentStoreEventEnvelopeSchema,
-  AgentStoreEventPageSchema,
-  AgentStoreTransitionSchema,
-  AppendAgentStoreEventSchema,
-  CheckpointRunAssistantSchema,
-  CommitRunTerminalSchema,
-  ReadAgentStoreEventsSchema,
-  RecordRunOperationSchema,
-  RecoverAgentRunSchema,
-  ReplaceCompactedRangeSchema,
-  RequestRunInterruptSchema,
-  SeedConversationInputSchema,
-  agentStoreEventDraft,
-  assistantStatus,
-  canonicalAgentJson,
-  decodeAgentConversationArchive,
-  encodeAgentConversationArchive
-} from "./index-zwkgfq1s.js";
-import {
-  AgentMessageSchema,
-  AgentRecordIdSchema,
-  AgentRecordVersionSchema,
-  AgentRunSchema,
-  AgentSnapshotSchema,
-  runStateForTerminalReason
-} from "./index-gtj3zc53.js";
-
-// src/agent-runtime/purge.ts
-import { z } from "zod";
-var AgentConversationPurgeInputSchema = z.strictObject({
-  conversationId: AgentRecordIdSchema,
-  expectedVersion: AgentRecordVersionSchema.optional()
-});
-var AgentConversationPurgeResultSchema = z.discriminatedUnion("outcome", [
-  z.strictObject({ outcome: z.literal("purged") }),
-  z.strictObject({ outcome: z.literal("already_purged") }),
-  z.strictObject({ outcome: z.literal("unsupported") }),
-  z.strictObject({
-    outcome: z.literal("active"),
-    runIds: z.array(AgentRecordIdSchema).min(1)
-  }),
-  z.strictObject({ outcome: z.literal("conflict"), actualVersion: AgentRecordVersionSchema })
-]);
-
-class AgentConversationPurgedError extends Error {
-  constructor() {
-    super("Agent conversation has been purged; use a new conversation ID");
-    this.name = "AgentConversationPurgedError";
-  }
-}
-async function purgeAgentConversation(store, input) {
-  const parsed = AgentConversationPurgeInputSchema.parse(input);
-  if (!store.purgeConversation)
-    return { outcome: "unsupported" };
-  return AgentConversationPurgeResultSchema.parse(await store.purgeConversation(parsed));
-}
-
-// src/agent-runtime/store-driver.ts
-import { createHash } from "node:crypto";
-import { z as z2 } from "zod";
-
-// src/agent-runtime/store-purge.ts
-function createStoreConversationPurge(driver, conversations) {
-  return async (input) => {
-    const { conversationId, expectedVersion } = AgentConversationPurgeInputSchema.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-driver.ts
-var AgentRuntimeHeadSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema
-});
-var AgentStoredRunSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  run: AgentRunSchema,
-  terminalAssistant: AgentMessageSchema.optional()
-});
-var AgentAdmissionReceiptSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema,
-  idempotencyKey: z2.string().min(1),
-  input: AgentMessageSchema,
-  runId: AgentRecordIdSchema,
-  assistantMessageId: AgentRecordIdSchema
-});
-var AgentSeedReceiptSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  conversationId: AgentRecordIdSchema,
-  seedKey: z2.string().min(1),
-  messageIds: z2.array(AgentRecordIdSchema).min(1)
-});
-var AgentHistoryMutationSchema = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema }),
-  z2.object({
-    type: z2.literal("upsert-assistant"),
-    message: AgentMessageSchema
-  }),
-  z2.object({
-    type: z2.literal("replace-compacted-range"),
-    replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
-    summary: AgentMessageSchema
-  }),
-  z2.object({
-    type: z2.literal("seed"),
-    message: AgentMessageSchema
-  })
-]);
-var AgentRecoverableScanInputSchema = z2.object({
-  cursor: z2.string().min(1).optional(),
-  limit: z2.number().int().min(1).max(1000)
-});
-function transitionRecord(operation) {
-  if (operation.type !== "checkpoint")
-    return operation;
-  const { assistant, ...rest } = operation.input;
-  const body = canonicalAgentJson(assistant);
-  return {
-    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 emptyHead(conversationId) {
-  return AgentRuntimeHeadSchema.parse({
-    schemaVersion: 1,
-    conversationId,
-    version: 0
-  });
-}
-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 AgentSnapshotSchema.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");
-      }
-    }
-  }
-}
-var RecoverableCursorSchema = z2.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
-function recoverableCursor(input) {
-  return JSON.stringify([input.conversationId, input.run.id]);
-}
-function parseRecoverableCursor(cursor) {
-  return RecoverableCursorSchema.parse(JSON.parse(cursor));
-}
-function replaceRun(runs, next) {
-  return runs.map((run) => run.id === next.id ? next : run);
-}
-function replaceMessage(messages, next) {
-  return messages.some((message) => message.id === next.id) ? messages.map((message) => message.id === next.id ? next : message) : [...messages, next];
-}
-var ACTIVE_AGENT_RUN_STATES = [
-  "queued",
-  "running",
-  "interrupt_requested"
-];
-function isActiveRunState(state) {
-  return ACTIVE_AGENT_RUN_STATES.includes(state);
-}
-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: AgentSnapshotSchema.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 }
-  };
-}
-function reduceStore(current, operation) {
-  if (operation.type === "accept") {
-    const input = operation.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 ? AgentRunSchema.parse({
-      ...coalescedRun,
-      inputMessageIds: [...coalescedRun.inputMessageIds, input.input.id],
-      revision: coalescedRun.revision + 1,
-      updatedAt: new Date().toISOString()
-    }) : input.run;
-    const admissionReceipt = AgentAdmissionReceiptSchema.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: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: assignedRun })],
-      admissionReceipt,
-      historyMutations: [{ type: "admit", input: input.input }]
-    });
-  }
-  if (operation.type === "seed") {
-    const conversationId2 = operation.input.conversationId;
-    if (current.conversationId !== conversationId2)
-      return { outcome: "not_found" };
-    for (const message of operation.input.inputs) {
-      if (message.conversationId !== conversationId2 || 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: [...operation.input.inputs, ...current.messages] }, {
-      seedReceipt: AgentSeedReceiptSchema.parse({
-        schemaVersion: 1,
-        conversationId: conversationId2,
-        seedKey: operation.input.seedKey,
-        messageIds: operation.input.inputs.map((message) => message.id)
-      }),
-      historyMutations: [...operation.input.inputs].reverse().map((message) => ({
-        type: "seed",
-        message
-      }))
-    });
-  }
-  const conversationId = operation.input.conversationId;
-  const run = operation.type === "compact" ? undefined : current.runs.find((candidate) => candidate.id === operation.input.runId);
-  if (operation.type !== "compact" && !run)
-    return { outcome: "not_found" };
-  if (operation.type === "acquire" && run) {
-    const runPosition = current.runs.findIndex((candidate) => candidate.id === run.id);
-    const acquisitionBlocked = current.runs.some((candidate, index) => candidate.id !== run.id && (candidate.state === "running" || candidate.state === "interrupt_requested" || index < runPosition && candidate.state === "queued"));
-    if (run.revision !== operation.input.expectedRevision || run.state !== "queued" || acquisitionBlocked) {
-      return conflict(run.revision);
-    }
-    const next = AgentRunSchema.parse({
-      ...run,
-      state: "running",
-      executionSequence: run.executionSequence ?? current.version + 1,
-      ownerId: operation.input.ownerId,
-      fencingToken: (run.fencingToken ?? 0) + 1,
-      revision: run.revision + 1,
-      updatedAt: new Date().toISOString()
-    });
-    return applied(current, { runs: replaceRun(current.runs, next) }, {
-      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
-    });
-  }
-  if (operation.type === "checkpoint" && run) {
-    const input = operation.input;
-    if (run.revision !== input.expectedRevision || run.state !== "running" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== "streaming") {
-      return conflict(run.revision);
-    }
-    const next = AgentRunSchema.parse({
-      ...run,
-      ...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: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })],
-      historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
-    });
-  }
-  if (operation.type === "operation" && run) {
-    const input = operation.input;
-    if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken) {
-      return conflict(run.revision);
-    }
-    const next = AgentRunSchema.parse({
-      ...run,
-      lastOperation: input.operation,
-      revision: run.revision + 1,
-      updatedAt: new Date().toISOString()
-    });
-    return applied(current, { runs: replaceRun(current.runs, next) }, { runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })] });
-  }
-  if (operation.type === "interrupt" && run) {
-    if (run.revision !== operation.input.expectedRevision || run.state !== "running") {
-      return conflict(run.revision);
-    }
-    const next = AgentRunSchema.parse({
-      ...run,
-      state: "interrupt_requested",
-      revision: run.revision + 1,
-      updatedAt: new Date().toISOString()
-    });
-    return applied(current, { runs: replaceRun(current.runs, next) }, {
-      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
-    });
-  }
-  if (operation.type === "recover" && run) {
-    const input = operation.input;
-    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 = AgentRunSchema.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") {
-      const existingAssistant = current.messages.find((message) => message.id === run.assistantMessageId);
-      const assistant = AgentMessageSchema.parse({
-        ...existingAssistant ?? {
-          schemaVersion: 1,
-          id: run.assistantMessageId,
-          conversationId: run.conversationId,
-          runId: run.id,
-          role: "assistant",
-          parts: [],
-          createdAt: run.createdAt
-        },
-        status: "failed",
-        updatedAt: new Date().toISOString()
-      });
-      return applied(current, {
-        runs: replaceRun(current.runs, next),
-        messages: replaceMessage(current.messages, assistant)
-      }, {
-        runRecords: [
-          AgentStoredRunSchema.parse({
-            schemaVersion: 1,
-            run: next,
-            terminalAssistant: assistant
-          })
-        ],
-        historyMutations: [{ type: "upsert-assistant", message: assistant }]
-      });
-    }
-    return applied(current, { runs: replaceRun(current.runs, next) }, {
-      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
-    });
-  }
-  if (operation.type === "terminal" && run) {
-    const input = operation.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 && runStateForTerminalReason(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 = AgentRunSchema.parse({
-      ...run,
-      state: runStateForTerminalReason(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 AgentRunSchema.parse({
-        ...candidate,
-        state: runStateForTerminalReason("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: [
-        AgentStoredRunSchema.parse({
-          schemaVersion: 1,
-          run: next,
-          terminalAssistant: input.assistant
-        }),
-        ...absorbedRuns.map((absorbed) => AgentStoredRunSchema.parse({ schemaVersion: 1, run: absorbed }))
-      ],
-      historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
-    });
-  }
-  if (operation.type === "compact") {
-    const input = operation.input;
-    if (current.conversationId !== conversationId)
-      return { outcome: "not_found" };
-    if (current.version !== input.expectedVersion)
-      return conflict(current.version);
-    const replaced = new Set(input.replacedMessageIds);
-    if (!input.replacedMessageIds.every((id) => current.messages.some((m) => m.id === id))) {
-      return { outcome: "not_found" };
-    }
-    const liveAssistant = current.runs.find((candidate) => isActiveRunState(candidate.state) && replaced.has(candidate.assistantMessageId));
-    if (liveAssistant) {
-      throw new TypeError(`Compaction may not replace the assistant message of run ${liveAssistant.id}, which has not finished`);
-    }
-    const positions = current.messages.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
-    const first = positions[0];
-    if (first === undefined || positions.some((position, offset) => position !== first + offset) || input.summary.conversationId !== input.conversationId || input.summary.runId !== undefined || input.summary.role !== "summary" || input.summary.status !== "committed" || current.messages.some((message) => message.id === input.summary.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.summary.id)) {
-      throw new TypeError("Compaction replacement must be one valid contiguous history range");
-    }
-    const messages = [
-      ...current.messages.slice(0, first),
-      input.summary,
-      ...current.messages.slice(first + positions.length)
-    ];
-    return applied(current, { messages }, {
-      historyMutations: [
-        {
-          type: "replace-compacted-range",
-          replacedMessageIds: input.replacedMessageIds,
-          summary: input.summary
-        }
-      ]
-    });
-  }
-  return { outcome: "not_found" };
-}
-function operationConversationId(operation) {
-  return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
-}
-function mergeRunRecords(...groups) {
-  const records = new Map;
-  for (const group of groups) {
-    for (const rawRecord of group) {
-      const record = AgentStoredRunSchema.parse(rawRecord);
-      const previous = records.get(record.run.id);
-      if (previous && previous.run.assistantMessageId !== record.run.assistantMessageId) {
-        throw new TypeError("Stored agent run identity changed across normalized records");
-      }
-      records.set(record.run.id, record);
-    }
-  }
-  return [...records.values()];
-}
-function referencedRunIds(messages) {
-  return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
-}
-function validateAdmissionReceipt(receipt, record, conversationId) {
-  const input = receipt.input;
-  const run = record.run;
-  if (receipt.conversationId !== conversationId || input.conversationId !== conversationId || input.role !== "user" || input.status !== "committed" || input.runId !== undefined || receipt.runId !== run.id || receipt.assistantMessageId !== run.assistantMessageId || !run.inputMessageIds.includes(input.id)) {
-    throw new TypeError("Admission receipt does not match its canonical run assignment");
-  }
-}
-function createAgentRuntimeStore(driver) {
-  const snapshotIn = async (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 = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
-    const referencedRecords = await driver.runs.loadMany(transaction, {
-      conversationId,
-      runIds: referencedRunIds(messages)
-    });
-    return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
-  };
-  const loadSnapshot = (conversationId) => driver.transaction((transaction) => snapshotIn(transaction, conversationId), {
-    access: "read"
-  });
-  const loadRun = (input) => 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 = AgentStoredRunSchema.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 = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(input.conversationId));
-    return AgentRunViewSchema.parse({
-      snapshotVersion: head.version,
-      run: parsed.run,
-      ...parsed.terminalAssistant && { assistant: parsed.terminalAssistant }
-    });
-  }, { access: "read" });
-  const listActiveRuns = (conversationId) => 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) => AgentStoredRunSchema.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" });
-  const mutate = (operation) => driver.transaction(async (transaction) => {
-    const conversationId = operationConversationId(operation);
-    if (await driver.conversations?.isPurged(transaction, conversationId)) {
-      throw new AgentConversationPurgedError;
-    }
-    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 = AgentRuntimeHeadSchema.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);
-    if (operation.type === "seed") {
-      const existing = await driver.seeds.load(transaction, {
-        conversationId,
-        seedKey: operation.input.seedKey
-      });
-      if (existing)
-        return { outcome: "applied", snapshot: current };
-      let collisions = 0;
-      for (const message of operation.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 < operation.input.inputs.length) {
-        throw new TypeError("Partial instruction seed collision: restore the complete seed before retrying");
-      }
-      if (collisions > 0) {
-        await driver.seeds.create(transaction, AgentSeedReceiptSchema.parse({
-          schemaVersion: 1,
-          conversationId,
-          seedKey: operation.input.seedKey,
-          messageIds: operation.input.inputs.map((message) => message.id)
-        }));
-        return { outcome: "applied", snapshot: current };
-      }
-    }
-    if (duplicateReceipt) {
-      const duplicateRecord = await driver.runs.load(transaction, {
-        conversationId,
-        runId: duplicateReceipt.runId
-      });
-      if (!duplicateRecord) {
-        throw new TypeError("Admission receipt points to a missing canonical run");
-      }
-      validateAdmissionReceipt(duplicateReceipt, duplicateRecord, conversationId);
-      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] : []))
-      };
-    }
-    if (operation.type === "accept") {
-      const inputCollision = await driver.admissions.loadByInputMessageId(transaction, {
-        conversationId,
-        inputMessageId: operation.input.input.id
-      });
-      if (inputCollision) {
-        throw new TypeError("Input message identity is already assigned to an admission");
-      }
-      if (!operation.input.coalesceIntoRunId) {
-        const [runCollision, assistantCollision] = await Promise.all([
-          driver.runs.load(transaction, {
-            conversationId,
-            runId: operation.input.run.id
-          }),
-          driver.runs.loadByAssistantMessageId(transaction, {
-            conversationId,
-            assistantMessageId: operation.input.run.assistantMessageId
-          })
-        ]);
-        if (runCollision || assistantCollision) {
-          throw new TypeError("Queued run identities are already reserved");
-        }
-      }
-    }
-    const reduced = reduceStore(current, operation);
-    if (reduced.outcome !== "applied")
-      return reduced;
-    const nextHead = AgentRuntimeHeadSchema.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: z2.json().parse(transitionRecord(operation))
-    }));
-    return { outcome: "applied", snapshot: reduced.snapshot };
-  });
-  const appendEvent = (input) => {
-    const parsed = AppendAgentStoreEventSchema.parse(input);
-    return driver.transaction(async (transaction) => {
-      if (await driver.conversations?.isPurged(transaction, parsed.conversationId)) {
-        throw new AgentConversationPurgedError;
-      }
-      return driver.events.append(transaction, agentStoreEventDraft(parsed));
-    });
-  };
-  const readEvents = (input) => {
-    const parsed = ReadAgentStoreEventsSchema.parse(input);
-    return driver.transaction(async (transaction) => AgentStoreEventPageSchema.parse(await driver.events.list(transaction, parsed)), { access: "read" });
-  };
-  const exportConversation = (conversationId) => driver.transaction(async (transaction) => {
-    const events = [];
-    let fromSeq;
-    do {
-      const page = AgentStoreEventPageSchema.parse(await driver.events.list(transaction, ReadAgentStoreEventsSchema.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(transaction, conversationId);
-    return encodeAgentConversationArchive({
-      format: "stitchkit.agent-conversation",
-      formatVersion: 1,
-      conversationId,
-      events,
-      projections: [
-        { archiveType: "runtime-snapshot", snapshot: z2.json().parse(snapshot) },
-        ...durable.projections
-      ],
-      spills: durable.spills
-    });
-  }, { access: "read" });
-  const importConversation = async (bytes) => {
-    const archive = decodeAgentConversationArchive(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 = AgentSnapshotSchema.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: AgentRuntimeHeadSchema.parse({
-              schemaVersion: 1,
-              conversationId: snapshot.conversationId,
-              version: snapshot.version
-            })
-          });
-          if (outcome.outcome !== "applied") {
-            throw new TypeError("Conversation archive snapshot target is not empty");
-          }
-        }
-        for (const run of snapshot.runs) {
-          const terminalAssistant = snapshot.messages.find((message) => message.id === run.assistantMessageId);
-          await driver.runs.save(transaction, AgentStoredRunSchema.parse({
-            schemaVersion: 1,
-            run,
-            ...terminalAssistant && { terminalAssistant }
-          }));
-        }
-        for (const message of snapshot.messages) {
-          await driver.history.apply(transaction, { type: "admit", input: message });
-        }
-        for (const event of archive.events) {
-          if (event.kind !== "runtime/transition")
-            continue;
-          const transition = AgentStoreTransitionSchema.parse(event.payload);
-          if (transition.type !== "accept")
-            continue;
-          const assigned = snapshot.runs.find((run) => run.inputMessageIds.includes(transition.input.input.id));
-          if (!assigned) {
-            throw new TypeError("Conversation archive admission has no assigned run");
-          }
-          await driver.admissions.create(transaction, AgentAdmissionReceiptSchema.parse({
-            schemaVersion: 1,
-            conversationId: archive.conversationId,
-            idempotencyKey: transition.input.idempotencyKey,
-            input: transition.input.input,
-            runId: assigned.id,
-            assistantMessageId: assigned.assistantMessageId
-          }));
-        }
-      }
-      await driver.archive?.import(transaction, archive);
-      return { conversationId: archive.conversationId, events: archive.events.length };
-    });
-  };
-  return {
-    loadSnapshot,
-    loadRun,
-    listActiveRuns,
-    appendEvent,
-    readEvents,
-    exportConversation,
-    importConversation,
-    ...driver.conversations && {
-      purgeConversation: createStoreConversationPurge(driver, driver.conversations)
-    },
-    acceptInputAndAssignRun: (input) => mutate({
-      type: "accept",
-      input: AcceptInputAndAssignRunSchema.parse(input)
-    }),
-    acquireRun: (input) => mutate({ type: "acquire", input: AcquireAgentRunSchema.parse(input) }),
-    checkpointRunAssistant: (input) => mutate({
-      type: "checkpoint",
-      input: CheckpointRunAssistantSchema.parse(input)
-    }),
-    recordRunOperation: (input) => mutate({
-      type: "operation",
-      input: RecordRunOperationSchema.parse(input)
-    }),
-    requestRunInterrupt: (input) => mutate({
-      type: "interrupt",
-      input: RequestRunInterruptSchema.parse(input)
-    }),
-    recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema.parse(input) }),
-    commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema.parse(input) }),
-    replaceCompactedRange: (input) => mutate({
-      type: "compact",
-      input: ReplaceCompactedRangeSchema.parse(input)
-    }),
-    seedConversationInput: (input) => mutate({
-      type: "seed",
-      input: SeedConversationInputSchema.parse(input)
-    }),
-    async scanRecoverable(input) {
-      const parsed = AgentRecoverableScanInputSchema.parse(input);
-      return AgentRecoverablePageSchema.parse(await driver.scanRecoverable(parsed));
-    }
-  };
-}
-function cloneHeadMap(source) {
-  return new Map([...source].map(([key, value]) => [
-    key,
-    AgentRuntimeHeadSchema.parse(structuredClone(value))
-  ]));
-}
-function cloneNestedMap(source, clone) {
-  return new Map([...source].map(([outerKey, values]) => [
-    outerKey,
-    new Map([...values].map(([innerKey, value]) => [innerKey, clone(value)]))
-  ]));
-}
-function cloneHistoryMap(source) {
-  return new Map([...source].map(([key, value]) => [
-    key,
-    value.map((message) => AgentMessageSchema.parse(structuredClone(message)))
-  ]));
-}
-function createMemoryAgentRuntimeStore() {
-  let purged = new Set;
-  let heads = new Map;
-  let runs = new Map;
-  let admissions = new Map;
-  let seeds = new Map;
-  let histories = new Map;
-  let events = new Map;
-  let transactionTail = Promise.resolve();
-  const driver = {
-    async transaction(work) {
-      const previous = transactionTail;
-      const release = Promise.withResolvers();
-      transactionTail = previous.catch(() => {
-        return;
-      }).then(() => release.promise);
-      await previous.catch(() => {
-        return;
-      });
-      const transaction = {
-        purged: new Set(purged),
-        heads: cloneHeadMap(heads),
-        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
-        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
-        seeds: cloneNestedMap(seeds, (receipt) => AgentSeedReceiptSchema.parse(structuredClone(receipt))),
-        histories: cloneHistoryMap(histories),
-        events: new Map([...events].map(([conversationId, stored]) => [
-          conversationId,
-          stored.map((event) => AgentStoreEventEnvelopeSchema.parse(structuredClone(event)))
-        ]))
-      };
-      try {
-        const result = await work(transaction);
-        purged = transaction.purged;
-        heads = transaction.heads;
-        runs = transaction.runs;
-        admissions = transaction.admissions;
-        seeds = transaction.seeds;
-        histories = transaction.histories;
-        events = transaction.events;
-        return result;
-      } finally {
-        release.resolve();
-      }
-    },
-    conversations: {
-      async isPurged(transaction, conversationId) {
-        return transaction.purged.has(conversationId);
-      },
-      async remove(transaction, conversationId) {
-        transaction.purged.add(conversationId);
-        transaction.heads.delete(conversationId);
-        transaction.runs.delete(conversationId);
-        transaction.admissions.delete(conversationId);
-        transaction.seeds.delete(conversationId);
-        transaction.histories.delete(conversationId);
-        transaction.events.delete(conversationId);
-      }
-    },
-    head: {
-      async load(transaction, conversationId) {
-        const head = transaction.heads.get(conversationId);
-        return head ? AgentRuntimeHeadSchema.parse(structuredClone(head)) : undefined;
-      },
-      async compareAndSwap(transaction, input) {
-        const current = transaction.heads.get(input.conversationId);
-        const actualVersion = current?.version ?? 0;
-        if (actualVersion !== input.expectedVersion) {
-          return { outcome: "conflict", actualVersion };
-        }
-        transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema.parse(structuredClone(input.next)));
-        return { outcome: "applied" };
-      }
-    },
-    runs: {
-      async load(transaction, input) {
-        const record = transaction.runs.get(input.conversationId)?.get(input.runId);
-        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
-      },
-      async loadByAssistantMessageId(transaction, input) {
-        const record = [...transaction.runs.get(input.conversationId)?.values() ?? []].find((candidate) => candidate.run.assistantMessageId === input.assistantMessageId);
-        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
-      },
-      async loadMany(transaction, input) {
-        const records = transaction.runs.get(input.conversationId);
-        return input.runIds.flatMap((runId) => {
-          const record = records?.get(runId);
-          return record ? [AgentStoredRunSchema.parse(structuredClone(record))] : [];
-        });
-      },
-      async listActive(transaction, conversationId) {
-        return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => isActiveRunState(record.run.state)).map((record) => AgentStoredRunSchema.parse(structuredClone(record)));
-      },
-      async save(transaction, rawRecord) {
-        const record = AgentStoredRunSchema.parse(structuredClone(rawRecord));
-        const conversationRuns = transaction.runs.get(record.run.conversationId) ?? new Map;
-        const collision = [...conversationRuns.values()].find((candidate) => candidate.run.id !== record.run.id && candidate.run.assistantMessageId === record.run.assistantMessageId);
-        if (collision)
-          throw new TypeError("Assistant message identity is already reserved");
-        conversationRuns.set(record.run.id, record);
-        transaction.runs.set(record.run.conversationId, conversationRuns);
-      }
-    },
-    admissions: {
-      async load(transaction, input) {
-        const receipt = transaction.admissions.get(input.conversationId)?.get(input.idempotencyKey);
-        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
-      },
-      async loadByInputMessageId(transaction, input) {
-        const receipt = [
-          ...transaction.admissions.get(input.conversationId)?.values() ?? []
-        ].find((candidate) => candidate.input.id === input.inputMessageId);
-        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
-      },
-      async create(transaction, rawReceipt) {
-        const receipt = AgentAdmissionReceiptSchema.parse(structuredClone(rawReceipt));
-        const conversationAdmissions = transaction.admissions.get(receipt.conversationId) ?? new Map;
-        if (conversationAdmissions.has(receipt.idempotencyKey) || [...conversationAdmissions.values()].some((candidate) => candidate.input.id === receipt.input.id)) {
-          throw new TypeError("Admission identity is already reserved");
-        }
-        conversationAdmissions.set(receipt.idempotencyKey, receipt);
-        transaction.admissions.set(receipt.conversationId, conversationAdmissions);
-      }
-    },
-    seeds: {
-      async load(transaction, input) {
-        const receipt = transaction.seeds.get(input.conversationId)?.get(input.seedKey);
-        return receipt ? AgentSeedReceiptSchema.parse(structuredClone(receipt)) : undefined;
-      },
-      async create(transaction, rawReceipt) {
-        const receipt = AgentSeedReceiptSchema.parse(structuredClone(rawReceipt));
-        const conversationSeeds = transaction.seeds.get(receipt.conversationId) ?? new Map;
-        if (conversationSeeds.has(receipt.seedKey)) {
-          throw new TypeError("Conversation seed identity is already reserved");
-        }
-        conversationSeeds.set(receipt.seedKey, receipt);
-        transaction.seeds.set(receipt.conversationId, conversationSeeds);
-      }
-    },
-    history: {
-      async load(transaction, conversationId) {
-        return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema.parse(structuredClone(message)));
-      },
-      async hasMessage(transaction, input) {
-        return (transaction.histories.get(input.conversationId) ?? []).some((message) => message.id === input.messageId);
-      },
-      async apply(transaction, rawMutation) {
-        const mutation = AgentHistoryMutationSchema.parse(rawMutation);
-        const conversationId = mutation.type === "admit" ? mutation.input.conversationId : mutation.type === "upsert-assistant" ? mutation.message.conversationId : mutation.type === "seed" ? mutation.message.conversationId : mutation.summary.conversationId;
-        const current = transaction.histories.get(conversationId) ?? [];
-        if (mutation.type === "admit") {
-          transaction.histories.set(conversationId, [...current, mutation.input]);
-          return;
-        }
-        if (mutation.type === "upsert-assistant") {
-          transaction.histories.set(conversationId, replaceMessage(current, mutation.message));
-          return;
-        }
-        if (mutation.type === "seed") {
-          const existingIndex = current.findIndex((message) => message.id === mutation.message.id);
-          if (existingIndex === -1) {
-            transaction.histories.set(conversationId, [mutation.message, ...current]);
-          } else {
-            const next = [...current];
-            next[existingIndex] = mutation.message;
-            transaction.histories.set(conversationId, next);
-          }
-          return;
-        }
-        const replaced = new Set(mutation.replacedMessageIds);
-        const positions = current.map((message, index) => replaced.has(message.id) ? index : undefined).filter((index) => index !== undefined);
-        const first = positions[0];
-        if (first === undefined)
-          throw new Error("Compaction history range disappeared");
-        transaction.histories.set(conversationId, [
-          ...current.slice(0, first),
-          mutation.summary,
-          ...current.slice(first + positions.length)
-        ]);
-      }
-    },
-    events: {
-      async append(transaction, draft) {
-        const current = transaction.events.get(draft.conversationId) ?? [];
-        const event = AgentStoreEventEnvelopeSchema.parse({
-          ...draft,
-          seq: (current.at(-1)?.seq ?? 0) + 1
-        });
-        if (current.some((candidate) => candidate.eventId === event.eventId)) {
-          throw new TypeError("Agent store event identity is already present");
-        }
-        transaction.events.set(draft.conversationId, [...current, event]);
-        return event;
-      },
-      async list(transaction, input) {
-        const selected = (transaction.events.get(input.conversationId) ?? []).filter((event) => (input.fromSeq === undefined || event.seq >= input.fromSeq) && (input.toSeq === undefined || event.seq <= input.toSeq));
-        const items = selected.slice(0, input.limit);
-        const last = items.at(-1);
-        return AgentStoreEventPageSchema.parse({
-          items,
-          ...selected.length > items.length && last ? { nextSeq: last.seq + 1 } : {}
-        });
-      }
-    },
-    async scanRecoverable(input) {
-      const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => isActiveRunState(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
-      const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
-      const start = cursorTuple ? descriptors.findIndex((item) => item.conversationId.localeCompare(cursorTuple[0]) > 0 || item.conversationId === cursorTuple[0] && item.run.id.localeCompare(cursorTuple[1]) > 0) : 0;
-      if (start === -1) {
-        return AgentRecoverablePageSchema.parse({ items: [] });
-      }
-      const items = descriptors.slice(start, start + input.limit);
-      const last = items.at(-1);
-      const hasMore = start + items.length < descriptors.length;
-      return AgentRecoverablePageSchema.parse({
-        items,
-        ...hasMore && last && { nextCursor: recoverableCursor(last) }
-      });
-    }
-  };
-  return createAgentRuntimeStore(driver);
-}
-
-export { AgentConversationPurgeInputSchema, AgentConversationPurgeResultSchema, AgentConversationPurgedError, purgeAgentConversation, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentSeedReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };