stitchkit 0.58.0 → 0.59.0

package/dist/agent-runtime.js

@@ -1724,7 +1724,7 @@ function createAgentRuntime(config) {
           });
           const acceptedSnapshot = appliedSnapshot(acceptance, "input acceptance");
           const assignedRunId = acceptance.outcome === "duplicate" ? acceptance.runId : reservation?.admission.runId ?? runId;
-          const acceptedRun = findRun(acceptedSnapshot.runs, assignedRunId);
+          const acceptedRun = acceptance.outcome === "duplicate" ? acceptance.run : findRun(acceptedSnapshot.runs, assignedRunId);
           const actualInputMessageId = acceptance.outcome === "duplicate" ? acceptance.inputMessageId : userMessage2.id;
           const acceptedInput = acceptance.outcome === "duplicate" ? acceptance.input : acceptedSnapshot.messages.find((candidate) => candidate.id === actualInputMessageId);
           if (!acceptedInput) {
@@ -1739,7 +1739,7 @@ function createAgentRuntime(config) {
             createdAt: acceptedRun.createdAt,
             updatedAt: acceptedRun.updatedAt
           });
-          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptedSnapshot.messages.find((candidate) => candidate.id === acceptedRun.assistantMessageId) ?? assistantPlaceholder : assistantPlaceholder;
+          const acceptedAssistant = acceptance.outcome === "duplicate" ? acceptance.assistant ?? assistantPlaceholder : assistantPlaceholder;
           const admission = {
             inputMessageId: acceptedInput.id,
             runId: acceptedRun.id,
@@ -1781,9 +1781,9 @@ function createAgentRuntime(config) {
               }
               return;
             }
-            const message = acceptedSnapshot.messages.find((candidate) => candidate.id === acceptedRun.assistantMessageId);
+            const message = acceptance.assistant;
             if (!message) {
-              const error = new Error("Duplicate terminal run has no assistant message");
+              const error = new Error("Duplicate terminal admission has no retained canonical assistant");
               outerResult.reject(error);
               if (reservation?.shouldSchedule) {
                 reservation.admission.completion.reject(error);
@@ -1996,6 +1996,8 @@ var AgentStoreDuplicateSchema = z6.object({
   inputMessageId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   assistantMessageId: AgentRecordIdSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional(),
   snapshot: AgentSnapshotSchema
 });
 var AgentStoreMutationResultSchema = z6.discriminatedUnion("outcome", [
@@ -2055,18 +2057,23 @@ var ReplaceCompactedRangeSchema = z6.object({
 });
 // src/agent-runtime/store-driver.ts
 import { z as z7 } from "zod";
-var AgentAdmissionIdentitySchema = z7.object({
-  idempotencyKey: z7.string().min(1),
-  inputMessageId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  assistantMessageId: AgentRecordIdSchema
+var AgentRuntimeHeadSchema = z7.object({
+  schemaVersion: z7.literal(1),
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema
+});
+var AgentStoredRunSchema = z7.object({
+  schemaVersion: z7.literal(1),
+  run: AgentRunSchema,
+  terminalAssistant: AgentMessageSchema.optional()
 });
-var AgentStoredStateSchema = z7.object({
+var AgentAdmissionReceiptSchema = z7.object({
   schemaVersion: z7.literal(1),
   conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  runs: z7.array(AgentRunSchema),
-  admissions: z7.array(AgentAdmissionIdentitySchema)
+  idempotencyKey: z7.string().min(1),
+  input: AgentMessageSchema,
+  runId: AgentRecordIdSchema,
+  assistantMessageId: AgentRecordIdSchema
 });
 var AgentHistoryMutationSchema = z7.discriminatedUnion("type", [
   z7.object({ type: z7.literal("admit"), input: AgentMessageSchema }),
@@ -2092,40 +2099,40 @@ var AgentRecoverableScanInputSchema = z7.object({
   cursor: z7.string().min(1).optional(),
   limit: z7.number().int().min(1).max(1000)
 });
-function emptyState(conversationId) {
-  return AgentStoredStateSchema.parse({
+function emptyHead(conversationId) {
+  return AgentRuntimeHeadSchema.parse({
     schemaVersion: 1,
     conversationId,
-    version: 0,
-    runs: [],
-    admissions: []
+    version: 0
   });
 }
-function snapshotOf(state, messages) {
-  validateAggregate(state, messages);
+function snapshotOf(head, messages, records) {
+  validateSnapshot(head, messages, records);
   return AgentSnapshotSchema.parse({
     schemaVersion: 1,
-    conversationId: state.conversationId,
-    version: state.version,
+    conversationId: head.conversationId,
+    version: head.version,
     messages,
-    runs: state.runs
+    runs: records.map((record) => record.run).sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id))
   });
 }
-function validateAggregate(state, messages) {
+function validateSnapshot(head, messages, records) {
   const runIds = new Set;
   const assistantIds = new Set;
   const messageIds = new Set;
-  const idempotencyKeys = new Set;
-  const admittedInputIds = new Set;
-  for (const run of state.runs) {
-    if (run.conversationId !== state.conversationId || runIds.has(run.id) || assistantIds.has(run.assistantMessageId)) {
-      throw new TypeError("Stored agent state contains inconsistent run identities");
+  for (const record of records) {
+    const run = record.run;
+    if (run.conversationId !== head.conversationId || runIds.has(run.id) || assistantIds.has(run.assistantMessageId)) {
+      throw new TypeError("Stored agent runs contain inconsistent identities");
+    }
+    if (record.terminalAssistant && (record.terminalAssistant.id !== run.assistantMessageId || record.terminalAssistant.conversationId !== run.conversationId || record.terminalAssistant.runId !== run.id || record.terminalAssistant.role !== "assistant" || run.terminalReason === undefined)) {
+      throw new TypeError("Retained terminal assistant does not match its run");
     }
     runIds.add(run.id);
     assistantIds.add(run.assistantMessageId);
   }
   for (const message of messages) {
-    if (message.conversationId !== state.conversationId || messageIds.has(message.id)) {
+    if (message.conversationId !== head.conversationId || messageIds.has(message.id)) {
       throw new TypeError("Stored agent history contains inconsistent message identities");
     }
     messageIds.add(message.id);
@@ -2133,23 +2140,12 @@ function validateAggregate(state, messages) {
       throw new TypeError("Stored history occupies a reserved assistant identity");
     }
     if (message.runId !== undefined) {
-      const run = state.runs.find((candidate) => candidate.id === message.runId);
+      const run = records.find((candidate) => candidate.run.id === message.runId)?.run;
       if (!run || message.role !== "assistant" || run.assistantMessageId !== message.id) {
         throw new TypeError("Stored assistant history does not match its reserved run identity");
       }
     }
   }
-  for (const admission of state.admissions) {
-    const run = state.runs.find((candidate) => candidate.id === admission.runId);
-    if (idempotencyKeys.has(admission.idempotencyKey) || admittedInputIds.has(admission.inputMessageId) || !run || run.assistantMessageId !== admission.assistantMessageId || !run.inputMessageIds.includes(admission.inputMessageId)) {
-      throw new TypeError("Stored admission identity is inconsistent with its assigned run");
-    }
-    idempotencyKeys.add(admission.idempotencyKey);
-    admittedInputIds.add(admission.inputMessageId);
-  }
-}
-function recoverableDescriptors(state) {
-  return state.runs.filter((run) => ["queued", "running", "interrupt_requested"].includes(run.state)).map((run) => ({ conversationId: state.conversationId, run }));
 }
 var RecoverableCursorSchema = z7.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
 function recoverableCursor(input) {
@@ -2187,7 +2183,7 @@ function terminalMessageStatus(reason) {
   }
   return "failed";
 }
-function applied(current, admissions, input, historyMutation) {
+function applied(current, input, effects) {
   return {
     outcome: "applied",
     snapshot: AgentSnapshotSchema.parse({
@@ -2196,27 +2192,14 @@ function applied(current, admissions, input, historyMutation) {
       runs: input.runs ?? current.runs,
       messages: input.messages ?? current.messages
     }),
-    admissions,
-    ...historyMutation && { historyMutation }
+    ...effects?.runRecord && { runRecord: effects.runRecord },
+    ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
+    ...effects?.historyMutation && { historyMutation: effects.historyMutation }
   };
 }
-function reduceStore(current, currentAdmissions, operation, duplicateInput) {
+function reduceStore(current, operation) {
   if (operation.type === "accept") {
     const input = operation.input;
-    const duplicate = currentAdmissions.find((candidate) => candidate.idempotencyKey === input.idempotencyKey);
-    if (duplicate) {
-      if (!duplicateInput) {
-        throw new Error("Duplicate admission input is unavailable from canonical history");
-      }
-      return {
-        outcome: "duplicate",
-        input: duplicateInput,
-        inputMessageId: duplicate.inputMessageId,
-        runId: duplicate.runId,
-        assistantMessageId: duplicate.assistantMessageId,
-        snapshot: current
-      };
-    }
     if (input.expectedVersion !== undefined && input.expectedVersion !== current.version) {
       return conflict(current.version);
     }
@@ -2233,16 +2216,25 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: coalescedRun.revision + 1,
       updatedAt: new Date().toISOString()
     }) : input.run;
-    const admission = AgentAdmissionIdentitySchema.parse({
+    const admissionReceipt = AgentAdmissionReceiptSchema.parse({
+      schemaVersion: 1,
+      conversationId: input.input.conversationId,
       idempotencyKey: input.idempotencyKey,
-      inputMessageId: input.input.id,
+      input: input.input,
       runId: assignedRun.id,
       assistantMessageId: assignedRun.assistantMessageId
     });
-    return applied(current, [...currentAdmissions, admission], {
+    return applied(current, {
       messages: [...current.messages, input.input],
       runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
-    }, { type: "admit", input: input.input });
+    }, {
+      runRecord: AgentStoredRunSchema.parse({
+        schemaVersion: 1,
+        run: assignedRun
+      }),
+      admissionReceipt,
+      historyMutation: { type: "admit", input: input.input }
+    });
   }
   const conversationId = operation.input.conversationId;
   const run = operation.type === "compact" ? undefined : current.runs.find((candidate) => candidate.id === operation.input.runId);
@@ -2262,8 +2254,8 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
-      runs: replaceRun(current.runs, next)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
     });
   }
   if (operation.type === "checkpoint" && run) {
@@ -2276,10 +2268,13 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
+    return applied(current, {
       runs: replaceRun(current.runs, next),
       messages: replaceMessage(current.messages, input.assistant)
-    }, { type: "upsert-assistant", message: input.assistant });
+    }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next }),
+      historyMutation: { type: "upsert-assistant", message: input.assistant }
+    });
   }
   if (operation.type === "interrupt" && run) {
     if (run.revision !== operation.input.expectedRevision || run.state !== "running") {
@@ -2291,8 +2286,8 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
-      runs: replaceRun(current.runs, next)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
     });
   }
   if (operation.type === "recover" && run) {
@@ -2330,13 +2325,20 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
         status: "failed",
         updatedAt: new Date().toISOString()
       });
-      return applied(current, currentAdmissions, {
+      return applied(current, {
         runs: replaceRun(current.runs, next),
         messages: replaceMessage(current.messages, assistant)
-      }, { type: "upsert-assistant", message: assistant });
+      }, {
+        runRecord: AgentStoredRunSchema.parse({
+          schemaVersion: 1,
+          run: next,
+          terminalAssistant: assistant
+        }),
+        historyMutation: { type: "upsert-assistant", message: assistant }
+      });
     }
-    return applied(current, currentAdmissions, {
-      runs: replaceRun(current.runs, next)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
     });
   }
   if (operation.type === "terminal" && run) {
@@ -2352,10 +2354,17 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
-    return applied(current, currentAdmissions, {
+    return applied(current, {
       runs: replaceRun(current.runs, next),
       messages: replaceMessage(current.messages, input.assistant)
-    }, { type: "upsert-assistant", message: input.assistant });
+    }, {
+      runRecord: AgentStoredRunSchema.parse({
+        schemaVersion: 1,
+        run: next,
+        terminalAssistant: input.assistant
+      }),
+      historyMutation: { type: "upsert-assistant", message: input.assistant }
+    });
   }
   if (operation.type === "compact") {
     const input = operation.input;
@@ -2377,10 +2386,12 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
       input.summary,
       ...current.messages.slice(first + positions.length)
     ];
-    return applied(current, currentAdmissions, { messages }, {
-      type: "replace-compacted-range",
-      replacedMessageIds: input.replacedMessageIds,
-      summary: input.summary
+    return applied(current, { messages }, {
+      historyMutation: {
+        type: "replace-compacted-range",
+        replacedMessageIds: input.replacedMessageIds,
+        summary: input.summary
+      }
     });
   }
   return { outcome: "not_found" };
@@ -2388,48 +2399,130 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
 function operationConversationId(operation) {
   return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
 }
+function mergeRunRecords(...groups) {
+  const records = new Map;
+  for (const group of groups) {
+    for (const rawRecord of group) {
+      const record = AgentStoredRunSchema.parse(rawRecord);
+      const previous = records.get(record.run.id);
+      if (previous && previous.run.assistantMessageId !== record.run.assistantMessageId) {
+        throw new TypeError("Stored agent run identity changed across normalized records");
+      }
+      records.set(record.run.id, record);
+    }
+  }
+  return [...records.values()];
+}
+function referencedRunIds(messages) {
+  return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
+}
+function validateAdmissionReceipt(receipt, record, conversationId) {
+  const input = receipt.input;
+  const run = record.run;
+  if (receipt.conversationId !== conversationId || input.conversationId !== conversationId || input.role !== "user" || input.status !== "committed" || input.runId !== undefined || receipt.runId !== run.id || receipt.assistantMessageId !== run.assistantMessageId || !run.inputMessageIds.includes(input.id)) {
+    throw new TypeError("Admission receipt does not match its canonical run assignment");
+  }
+}
 function createAgentRuntimeStore(driver) {
   const loadSnapshot = (conversationId) => driver.transaction(async (transaction) => {
-    const [stored, messages] = await Promise.all([
-      driver.state.load(transaction, conversationId),
-      driver.history.load(transaction, conversationId)
+    const [stored, messages, activeRecords] = await Promise.all([
+      driver.head.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId),
+      driver.runs.listActive(transaction, conversationId)
     ]);
-    return snapshotOf(stored ?? emptyState(conversationId), messages);
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+    const referencedRecords = await driver.runs.loadMany(transaction, {
+      conversationId,
+      runIds: referencedRunIds(messages)
+    });
+    return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
   });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);
-    const [stored, messages] = await Promise.all([
-      driver.state.load(transaction, conversationId),
-      driver.history.load(transaction, conversationId)
+    const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
+    const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
+      driver.head.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId),
+      driver.runs.listActive(transaction, conversationId),
+      operationRunId ? driver.runs.load(transaction, { conversationId, runId: operationRunId }) : undefined,
+      operation.type === "accept" ? driver.admissions.load(transaction, {
+        conversationId,
+        idempotencyKey: operation.input.idempotencyKey
+      }) : undefined
     ]);
-    const state = AgentStoredStateSchema.parse(stored ?? emptyState(conversationId));
-    const current = snapshotOf(state, messages);
-    const duplicateIdentity = operation.type === "accept" ? state.admissions.find((candidate) => candidate.idempotencyKey === operation.input.idempotencyKey) : undefined;
-    const duplicateInput = duplicateIdentity ? await driver.history.loadById(transaction, {
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+    const referencedRecords = await driver.runs.loadMany(transaction, {
       conversationId,
-      messageId: duplicateIdentity.inputMessageId
-    }) : undefined;
-    if (duplicateIdentity && duplicateInput && (duplicateInput.id !== duplicateIdentity.inputMessageId || duplicateInput.conversationId !== conversationId || duplicateInput.role !== "user" || duplicateInput.status !== "committed" || duplicateInput.runId !== undefined)) {
-      throw new TypeError("Canonical duplicate input does not match its admission identity");
+      runIds: referencedRunIds(messages)
+    });
+    const records = mergeRunRecords(activeRecords, referencedRecords, operationRecord ? [operationRecord] : []);
+    const current = snapshotOf(head, messages, records);
+    if (duplicateReceipt) {
+      const duplicateRecord = await driver.runs.load(transaction, {
+        conversationId,
+        runId: duplicateReceipt.runId
+      });
+      if (!duplicateRecord) {
+        throw new TypeError("Admission receipt points to a missing canonical run");
+      }
+      validateAdmissionReceipt(duplicateReceipt, duplicateRecord, conversationId);
+      return {
+        outcome: "duplicate",
+        input: duplicateReceipt.input,
+        inputMessageId: duplicateReceipt.input.id,
+        runId: duplicateReceipt.runId,
+        assistantMessageId: duplicateReceipt.assistantMessageId,
+        run: duplicateRecord.run,
+        ...duplicateRecord.terminalAssistant && {
+          assistant: duplicateRecord.terminalAssistant
+        },
+        snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord]))
+      };
+    }
+    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, state.admissions, operation, duplicateInput);
+    const reduced = reduceStore(current, operation);
     if (reduced.outcome !== "applied")
       return reduced;
-    const nextState = AgentStoredStateSchema.parse({
+    const nextHead = AgentRuntimeHeadSchema.parse({
       schemaVersion: 1,
       conversationId,
-      version: reduced.snapshot.version,
-      runs: reduced.snapshot.runs,
-      admissions: reduced.admissions
+      version: reduced.snapshot.version
     });
-    const outcome = await driver.state.compareAndSwap(transaction, {
+    const outcome = await driver.head.compareAndSwap(transaction, {
       conversationId,
       expectedVersion: current.version,
-      next: nextState,
-      recoverable: recoverableDescriptors(nextState)
+      next: nextHead
     });
     if (outcome.outcome === "conflict")
       return conflict(outcome.actualVersion);
+    if (reduced.runRecord)
+      await driver.runs.save(transaction, reduced.runRecord);
+    if (reduced.admissionReceipt) {
+      await driver.admissions.create(transaction, reduced.admissionReceipt);
+    }
     if (reduced.historyMutation) {
       await driver.history.apply(transaction, reduced.historyMutation);
     }
@@ -2481,10 +2574,16 @@ function createAgentRuntimeStore(driver) {
     }
   };
 }
-function cloneStateMap(source) {
+function cloneHeadMap(source) {
   return new Map([...source].map(([key, value]) => [
     key,
-    AgentStoredStateSchema.parse(structuredClone(value))
+    AgentRuntimeHeadSchema.parse(structuredClone(value))
+  ]));
+}
+function cloneNestedMap(source, clone) {
+  return new Map([...source].map(([outerKey, values]) => [
+    outerKey,
+    new Map([...values].map(([innerKey, value]) => [innerKey, clone(value)]))
   ]));
 }
 function cloneHistoryMap(source) {
@@ -2494,9 +2593,10 @@ function cloneHistoryMap(source) {
   ]));
 }
 function createMemoryAgentRuntimeStore() {
-  let states = new Map;
+  let heads = new Map;
+  let runs = new Map;
+  let admissions = new Map;
   let histories = new Map;
-  let archivedMessages = new Map;
   let transactionTail = Promise.resolve();
   const driver = {
     async transaction(work) {
@@ -2509,50 +2609,91 @@ function createMemoryAgentRuntimeStore() {
         return;
       });
       const transaction = {
-        states: cloneStateMap(states),
-        histories: cloneHistoryMap(histories),
-        archivedMessages: new Map([...archivedMessages].map(([conversationId, messages]) => [
-          conversationId,
-          new Map([...messages].map(([messageId, message]) => [
-            messageId,
-            AgentMessageSchema.parse(structuredClone(message))
-          ]))
-        ]))
+        heads: cloneHeadMap(heads),
+        runs: cloneNestedMap(runs, (record) => AgentStoredRunSchema.parse(structuredClone(record))),
+        admissions: cloneNestedMap(admissions, (receipt) => AgentAdmissionReceiptSchema.parse(structuredClone(receipt))),
+        histories: cloneHistoryMap(histories)
       };
       try {
         const result = await work(transaction);
-        states = transaction.states;
+        heads = transaction.heads;
+        runs = transaction.runs;
+        admissions = transaction.admissions;
         histories = transaction.histories;
-        archivedMessages = transaction.archivedMessages;
         return result;
       } finally {
         release.resolve();
       }
     },
-    state: {
+    head: {
       async load(transaction, conversationId) {
-        const state = transaction.states.get(conversationId);
-        return state ? AgentStoredStateSchema.parse(structuredClone(state)) : undefined;
+        const head = transaction.heads.get(conversationId);
+        return head ? AgentRuntimeHeadSchema.parse(structuredClone(head)) : undefined;
       },
       async compareAndSwap(transaction, input) {
-        const current = transaction.states.get(input.conversationId);
+        const current = transaction.heads.get(input.conversationId);
         const actualVersion = current?.version ?? 0;
         if (actualVersion !== input.expectedVersion) {
           return { outcome: "conflict", actualVersion };
         }
-        transaction.states.set(input.conversationId, AgentStoredStateSchema.parse(structuredClone(input.next)));
+        transaction.heads.set(input.conversationId, AgentRuntimeHeadSchema.parse(structuredClone(input.next)));
         return { outcome: "applied" };
       }
     },
+    runs: {
+      async load(transaction, input) {
+        const record = transaction.runs.get(input.conversationId)?.get(input.runId);
+        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+      },
+      async loadByAssistantMessageId(transaction, input) {
+        const record = [...transaction.runs.get(input.conversationId)?.values() ?? []].find((candidate) => candidate.run.assistantMessageId === input.assistantMessageId);
+        return record ? AgentStoredRunSchema.parse(structuredClone(record)) : undefined;
+      },
+      async loadMany(transaction, input) {
+        const records = transaction.runs.get(input.conversationId);
+        return input.runIds.flatMap((runId) => {
+          const record = records?.get(runId);
+          return record ? [AgentStoredRunSchema.parse(structuredClone(record))] : [];
+        });
+      },
+      async listActive(transaction, conversationId) {
+        return [...transaction.runs.get(conversationId)?.values() ?? []].filter((record) => ["queued", "running", "interrupt_requested"].includes(record.run.state)).map((record) => AgentStoredRunSchema.parse(structuredClone(record)));
+      },
+      async save(transaction, rawRecord) {
+        const record = AgentStoredRunSchema.parse(structuredClone(rawRecord));
+        const conversationRuns = transaction.runs.get(record.run.conversationId) ?? new Map;
+        const collision = [...conversationRuns.values()].find((candidate) => candidate.run.id !== record.run.id && candidate.run.assistantMessageId === record.run.assistantMessageId);
+        if (collision)
+          throw new TypeError("Assistant message identity is already reserved");
+        conversationRuns.set(record.run.id, record);
+        transaction.runs.set(record.run.conversationId, conversationRuns);
+      }
+    },
+    admissions: {
+      async load(transaction, input) {
+        const receipt = transaction.admissions.get(input.conversationId)?.get(input.idempotencyKey);
+        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+      },
+      async loadByInputMessageId(transaction, input) {
+        const receipt = [
+          ...transaction.admissions.get(input.conversationId)?.values() ?? []
+        ].find((candidate) => candidate.input.id === input.inputMessageId);
+        return receipt ? AgentAdmissionReceiptSchema.parse(structuredClone(receipt)) : undefined;
+      },
+      async create(transaction, rawReceipt) {
+        const receipt = AgentAdmissionReceiptSchema.parse(structuredClone(rawReceipt));
+        const conversationAdmissions = transaction.admissions.get(receipt.conversationId) ?? new Map;
+        if (conversationAdmissions.has(receipt.idempotencyKey) || [...conversationAdmissions.values()].some((candidate) => candidate.input.id === receipt.input.id)) {
+          throw new TypeError("Admission identity is already reserved");
+        }
+        conversationAdmissions.set(receipt.idempotencyKey, receipt);
+        transaction.admissions.set(receipt.conversationId, conversationAdmissions);
+      }
+    },
     history: {
       async load(transaction, conversationId) {
         return (transaction.histories.get(conversationId) ?? []).map((message) => AgentMessageSchema.parse(structuredClone(message)));
       },
-      async loadById(transaction, input) {
-        const active = (transaction.histories.get(input.conversationId) ?? []).find((message2) => message2.id === input.messageId);
-        const message = active ?? transaction.archivedMessages.get(input.conversationId)?.get(input.messageId);
-        return message ? AgentMessageSchema.parse(structuredClone(message)) : undefined;
-      },
       async apply(transaction, rawMutation) {
         const mutation = AgentHistoryMutationSchema.parse(rawMutation);
         const conversationId = mutation.type === "admit" ? mutation.input.conversationId : mutation.type === "upsert-assistant" ? mutation.message.conversationId : mutation.summary.conversationId;
@@ -2570,11 +2711,6 @@ function createMemoryAgentRuntimeStore() {
         const first = positions[0];
         if (first === undefined)
           throw new Error("Compaction history range disappeared");
-        const archive = transaction.archivedMessages.get(conversationId) ?? new Map;
-        for (const message of current.filter((candidate) => replaced.has(candidate.id))) {
-          archive.set(message.id, AgentMessageSchema.parse(structuredClone(message)));
-        }
-        transaction.archivedMessages.set(conversationId, archive);
         transaction.histories.set(conversationId, [
           ...current.slice(0, first),
           mutation.summary,
@@ -2583,7 +2719,7 @@ function createMemoryAgentRuntimeStore() {
       }
     },
     async scanRecoverable(input) {
-      const descriptors = [...states.values()].flatMap((state) => state.runs.filter((run) => ["queued", "running", "interrupt_requested"].includes(run.state)).map((run) => ({ conversationId: state.conversationId, run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
+      const descriptors = [...runs].flatMap(([conversationId, conversationRuns]) => [...conversationRuns.values()].filter((record) => ["queued", "running", "interrupt_requested"].includes(record.run.state)).map((record) => ({ conversationId, run: record.run }))).sort((left, right) => left.conversationId.localeCompare(right.conversationId) || left.run.id.localeCompare(right.run.id));
       const cursorTuple = input.cursor ? parseRecoverableCursor(input.cursor) : undefined;
       const start = cursorTuple ? descriptors.findIndex((item) => item.conversationId === cursorTuple[0] && item.run.id === cursorTuple[1]) + 1 : 0;
       const items = descriptors.slice(start, start + input.limit);
@@ -2601,7 +2737,7 @@ export {
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionEventSchema,
-  AgentAdmissionIdentitySchema,
+  AgentAdmissionReceiptSchema,
   AgentAssistantPlaceholderSchema,
   AgentCheckpointEventSchema,
   AgentControlPartSchema,
@@ -2633,6 +2769,7 @@ export {
   AgentRunStateSchema,
   AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
+  AgentRuntimeHeadSchema,
   AgentSnapshotSchema,
   AgentSourcePartSchema,
   AgentStoreAppliedSchema,
@@ -2640,7 +2777,7 @@ export {
   AgentStoreDuplicateSchema,
   AgentStoreMutationResultSchema,
   AgentStoreNotFoundSchema,
-  AgentStoredStateSchema,
+  AgentStoredRunSchema,
   AgentTerminalEventSchema,
   AgentTerminalReasonSchema,
   AgentTextPartSchema,