stitchkit 0.58.0 → 0.59.1

package/dist/agent-runtime.js

@@ -900,6 +900,8 @@ import {
   streamText
 } from "ai";
 import { z as z5 } from "zod";
+
+// src/agent-runtime/terminal-commit.ts
 class AgentRuntimeConflictError extends Error {
   constructor(operation) {
     super(`Agent runtime store conflict during ${operation}`);
@@ -911,6 +913,94 @@ function appliedSnapshot(result, operation) {
     return result.snapshot;
   throw new AgentRuntimeConflictError(operation);
 }
+function terminalMessageStatus(reason) {
+  if (reason === "success" || reason === "policy_stop")
+    return "completed";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+function canonicalTerminal(snapshot, runId, retainedAssistant) {
+  const run = snapshot.runs.find((candidate) => candidate.id === runId);
+  if (!run?.terminalReason)
+    return;
+  const assistant = snapshot.messages.find((message) => message.id === run.assistantMessageId) ?? retainedAssistant;
+  if (snapshot.conversationId !== run.conversationId || !assistant || assistant.id !== run.assistantMessageId || assistant.conversationId !== run.conversationId || assistant.runId !== run.id || assistant.role !== "assistant" || assistant.status !== terminalMessageStatus(run.terminalReason)) {
+    throw new AgentRuntimeConflictError("terminal result projection");
+  }
+  return {
+    snapshot,
+    run,
+    assistant,
+    reason: run.terminalReason,
+    committedByCaller: false,
+    ...run.terminalPolicyName && { policyName: run.terminalPolicyName }
+  };
+}
+function interruptedCandidate(candidate, run, now) {
+  const hasInterruptControl = candidate.assistant.parts.some((part) => part.type === "control" && part.reason === "run-interrupted");
+  const parts = hasInterruptControl ? candidate.assistant.parts : [
+    ...candidate.assistant.parts,
+    AgentMessagePartSchema.parse({ type: "control", reason: "run-interrupted" })
+  ];
+  return {
+    run,
+    assistant: AgentMessageSchema.parse({
+      ...candidate.assistant,
+      status: "interrupted",
+      parts,
+      updatedAt: now().toISOString()
+    }),
+    reason: "interrupted"
+  };
+}
+function canRetryTerminal(current, previous, runtimeEpoch) {
+  return (current.state === "running" || current.state === "interrupt_requested") && current.ownerId === runtimeEpoch && current.fencingToken === previous.fencingToken;
+}
+async function commitAgentRunTerminal(input) {
+  let candidate = input.candidate;
+  while (true) {
+    const committed = await input.store.commitRunTerminal({
+      conversationId: candidate.run.conversationId,
+      runId: candidate.run.id,
+      expectedRevision: candidate.run.revision,
+      ownerId: input.runtimeEpoch,
+      ...candidate.run.fencingToken !== undefined && {
+        fencingToken: candidate.run.fencingToken
+      },
+      assistant: candidate.assistant,
+      reason: candidate.reason,
+      ...candidate.policyName && { policyName: candidate.policyName }
+    });
+    if (committed.outcome === "applied") {
+      const terminal2 = canonicalTerminal(committed.snapshot, candidate.run.id);
+      if (!terminal2)
+        throw new AgentRuntimeConflictError("terminal result projection");
+      return { ...terminal2, committedByCaller: true };
+    }
+    if (committed.outcome === "duplicate") {
+      const terminal2 = canonicalTerminal(committed.snapshot, candidate.run.id, committed.assistant);
+      if (!terminal2)
+        throw new AgentRuntimeConflictError("terminal result projection");
+      return terminal2;
+    }
+    if (committed.outcome !== "conflict") {
+      throw new AgentRuntimeConflictError("terminal commit");
+    }
+    const latest = await input.store.loadSnapshot(candidate.run.conversationId);
+    const terminal = canonicalTerminal(latest, candidate.run.id);
+    if (terminal)
+      return terminal;
+    const current = latest.runs.find((run) => run.id === candidate.run.id);
+    if (!current || !canRetryTerminal(current, candidate.run, input.runtimeEpoch)) {
+      throw new AgentRuntimeConflictError("terminal commit");
+    }
+    candidate = current.state === "interrupt_requested" ? interruptedCandidate(candidate, current, input.now) : { ...candidate, run: current };
+  }
+}
+
+// src/agent-runtime/runtime.ts
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -1547,59 +1637,66 @@ function createAgentRuntime(config) {
       parts,
       updatedAt: now().toISOString()
     });
-    snapshot = appliedSnapshot(await config.store.commitRunTerminal({
-      conversationId: run.conversationId,
-      runId: run.id,
-      expectedRevision: run.revision,
-      ownerId: runtimeEpoch,
-      ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-      assistant,
-      reason: terminalReason,
-      ...terminalPolicyName && { policyName: terminalPolicyName }
-    }), "terminal commit");
-    run = findRun(snapshot.runs, run.id);
-    const terminalMetrics = {
+    const terminal = await commitAgentRunTerminal({
+      store: config.store,
+      runtimeEpoch,
+      candidate: {
+        run,
+        assistant,
+        reason: terminalReason,
+        ...terminalPolicyName && { policyName: terminalPolicyName }
+      },
+      now
+    });
+    snapshot = terminal.snapshot;
+    run = terminal.run;
+    assistant = terminal.assistant;
+    terminalReason = terminal.reason;
+    terminalPolicyName = terminal.policyName;
+    const terminalMetrics = terminal.committedByCaller ? {
       partial: false,
       durationMs: performance.now() - runStartedAt,
       ...usage && { usage },
       ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
-    };
-    config.observe?.emit({
-      schemaVersion: 1,
-      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
-      type: "run-terminal",
-      conversationId: run.conversationId,
-      runId: run.id,
-      traceId: trace?.traceId ?? generateId(),
-      spanId: trace?.spanId ?? generateId(),
-      ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
-      state: run.state,
-      terminalReason,
-      ...selectedModel && { modelId: selectedModel.descriptor.modelId },
-      durationMs: terminalMetrics.durationMs,
-      ...usage && { usage },
-      ...internalCause !== undefined && { internalCause },
-      ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
-      emittedAt: now().toISOString()
-    });
-    await publish({
-      type: "terminal",
-      eventId: agentDurableEventId("terminal", run.id, snapshot.version),
-      conversationId: run.conversationId,
-      runId: run.id,
-      snapshotVersion: snapshot.version,
-      reason: terminalReason,
-      ...terminalPolicyName && { policyName: terminalPolicyName },
-      message: assistant,
-      metrics: terminalMetrics,
-      emittedAt: now().toISOString()
-    });
+    } : undefined;
+    if (terminalMetrics) {
+      config.observe?.emit({
+        schemaVersion: 1,
+        eventId: agentDurableEventId("terminal", run.id, snapshot.version),
+        type: "run-terminal",
+        conversationId: run.conversationId,
+        runId: run.id,
+        traceId: trace?.traceId ?? generateId(),
+        spanId: trace?.spanId ?? generateId(),
+        ...trace?.parentSpanId && { parentSpanId: trace.parentSpanId },
+        state: run.state,
+        terminalReason,
+        ...selectedModel && { modelId: selectedModel.descriptor.modelId },
+        durationMs: terminalMetrics.durationMs,
+        ...usage && { usage },
+        ...internalCause !== undefined && { internalCause },
+        ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
+        emittedAt: now().toISOString()
+      });
+      await publish({
+        type: "terminal",
+        eventId: agentDurableEventId("terminal", run.id, snapshot.version),
+        conversationId: run.conversationId,
+        runId: run.id,
+        snapshotVersion: snapshot.version,
+        reason: terminalReason,
+        ...terminalPolicyName && { policyName: terminalPolicyName },
+        message: assistant,
+        metrics: terminalMetrics,
+        emittedAt: now().toISOString()
+      });
+    }
     return {
       run,
       message: assistant,
       reason: terminalReason,
       snapshotVersion: snapshot.version,
-      metrics: terminalMetrics,
+      ...terminalMetrics && { metrics: terminalMetrics },
       ...terminalPolicyName && { policyName: terminalPolicyName }
     };
   };
@@ -1724,7 +1821,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 +1836,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 +1878,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 +2093,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 +2154,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 AgentStoredStateSchema = z7.object({
+var AgentStoredRunSchema = z7.object({
+  schemaVersion: z7.literal(1),
+  run: AgentRunSchema,
+  terminalAssistant: AgentMessageSchema.optional()
+});
+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 +2196,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 +2237,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) {
@@ -2179,7 +2272,7 @@ function terminalState(reason) {
     return "abandoned";
   return "failed";
 }
-function terminalMessageStatus(reason) {
+function terminalMessageStatus2(reason) {
   if (reason === "success" || reason === "policy_stop")
     return "completed";
   if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
@@ -2187,7 +2280,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 +2289,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 +2313,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 +2351,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 +2365,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 +2383,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,18 +2422,25 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
         status: "failed",
         updatedAt: new Date().toISOString()
       });
-      return applied(current, currentAdmissions, {
+      return applied(current, {
         runs: replaceRun(current.runs, next),
         messages: replaceMessage(current.messages, assistant)
-      }, { type: "upsert-assistant", message: assistant });
+      }, {
+        runRecord: AgentStoredRunSchema.parse({
+          schemaVersion: 1,
+          run: next,
+          terminalAssistant: assistant
+        }),
+        historyMutation: { type: "upsert-assistant", message: assistant }
+      });
     }
-    return applied(current, currentAdmissions, {
-      runs: replaceRun(current.runs, next)
+    return applied(current, { runs: replaceRun(current.runs, next) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
     });
   }
   if (operation.type === "terminal" && run) {
     const input = operation.input;
-    if (run.revision !== input.expectedRevision || run.state !== "running" && run.state !== "interrupt_requested" || run.ownerId !== input.ownerId || input.fencingToken !== undefined && run.fencingToken !== input.fencingToken || input.assistant.runId !== run.id || input.assistant.id !== run.assistantMessageId || input.assistant.conversationId !== run.conversationId || input.assistant.role !== "assistant" || input.assistant.status !== terminalMessageStatus(input.reason)) {
+    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 !== terminalMessageStatus2(input.reason)) {
       return conflict(run.revision);
     }
     const next = AgentRunSchema.parse({
@@ -2352,10 +2451,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 +2483,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 +2496,130 @@ function reduceStore(current, currentAdmissions, operation, duplicateInput) {
 function operationConversationId(operation) {
   return operation.type === "accept" ? operation.input.input.conversationId : operation.input.conversationId;
 }
+function mergeRunRecords(...groups) {
+  const records = new Map;
+  for (const group of groups) {
+    for (const rawRecord of group) {
+      const record = AgentStoredRunSchema.parse(rawRecord);
+      const previous = records.get(record.run.id);
+      if (previous && previous.run.assistantMessageId !== record.run.assistantMessageId) {
+        throw new TypeError("Stored agent run identity changed across normalized records");
+      }
+      records.set(record.run.id, record);
+    }
+  }
+  return [...records.values()];
+}
+function referencedRunIds(messages) {
+  return [...new Set(messages.flatMap((message) => message.runId ? [message.runId] : []))];
+}
+function validateAdmissionReceipt(receipt, record, conversationId) {
+  const input = receipt.input;
+  const run = record.run;
+  if (receipt.conversationId !== conversationId || input.conversationId !== conversationId || input.role !== "user" || input.status !== "committed" || input.runId !== undefined || receipt.runId !== run.id || receipt.assistantMessageId !== run.assistantMessageId || !run.inputMessageIds.includes(input.id)) {
+    throw new TypeError("Admission receipt does not match its canonical run assignment");
+  }
+}
 function createAgentRuntimeStore(driver) {
   const loadSnapshot = (conversationId) => driver.transaction(async (transaction) => {
-    const [stored, messages] = await Promise.all([
-      driver.state.load(transaction, conversationId),
-      driver.history.load(transaction, conversationId)
+    const [stored, messages, activeRecords] = await Promise.all([
+      driver.head.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId),
+      driver.runs.listActive(transaction, conversationId)
     ]);
-    return snapshotOf(stored ?? emptyState(conversationId), messages);
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+    const referencedRecords = await driver.runs.loadMany(transaction, {
+      conversationId,
+      runIds: referencedRunIds(messages)
+    });
+    return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
   });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);
-    const [stored, messages] = await Promise.all([
-      driver.state.load(transaction, conversationId),
-      driver.history.load(transaction, conversationId)
+    const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
+    const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
+      driver.head.load(transaction, conversationId),
+      driver.history.load(transaction, conversationId),
+      driver.runs.listActive(transaction, conversationId),
+      operationRunId ? driver.runs.load(transaction, { conversationId, runId: operationRunId }) : undefined,
+      operation.type === "accept" ? driver.admissions.load(transaction, {
+        conversationId,
+        idempotencyKey: operation.input.idempotencyKey
+      }) : undefined
     ]);
-    const state = AgentStoredStateSchema.parse(stored ?? emptyState(conversationId));
-    const current = snapshotOf(state, messages);
-    const duplicateIdentity = operation.type === "accept" ? state.admissions.find((candidate) => candidate.idempotencyKey === operation.input.idempotencyKey) : undefined;
-    const duplicateInput = duplicateIdentity ? await driver.history.loadById(transaction, {
+    const head = AgentRuntimeHeadSchema.parse(stored ?? emptyHead(conversationId));
+    const referencedRecords = await driver.runs.loadMany(transaction, {
       conversationId,
-      messageId: duplicateIdentity.inputMessageId
-    }) : undefined;
-    if (duplicateIdentity && duplicateInput && (duplicateInput.id !== duplicateIdentity.inputMessageId || duplicateInput.conversationId !== conversationId || duplicateInput.role !== "user" || duplicateInput.status !== "committed" || duplicateInput.runId !== undefined)) {
-      throw new TypeError("Canonical duplicate input does not match its admission identity");
+      runIds: referencedRunIds(messages)
+    });
+    const records = mergeRunRecords(activeRecords, referencedRecords, operationRecord ? [operationRecord] : []);
+    const current = snapshotOf(head, messages, records);
+    if (duplicateReceipt) {
+      const duplicateRecord = await driver.runs.load(transaction, {
+        conversationId,
+        runId: duplicateReceipt.runId
+      });
+      if (!duplicateRecord) {
+        throw new TypeError("Admission receipt points to a missing canonical run");
+      }
+      validateAdmissionReceipt(duplicateReceipt, duplicateRecord, conversationId);
+      return {
+        outcome: "duplicate",
+        input: duplicateReceipt.input,
+        inputMessageId: duplicateReceipt.input.id,
+        runId: duplicateReceipt.runId,
+        assistantMessageId: duplicateReceipt.assistantMessageId,
+        run: duplicateRecord.run,
+        ...duplicateRecord.terminalAssistant && {
+          assistant: duplicateRecord.terminalAssistant
+        },
+        snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord]))
+      };
     }
-    const reduced = reduceStore(current, state.admissions, operation, duplicateInput);
+    if (operation.type === "accept") {
+      const inputCollision = await driver.admissions.loadByInputMessageId(transaction, {
+        conversationId,
+        inputMessageId: operation.input.input.id
+      });
+      if (inputCollision) {
+        throw new TypeError("Input message identity is already assigned to an admission");
+      }
+      if (!operation.input.coalesceIntoRunId) {
+        const [runCollision, assistantCollision] = await Promise.all([
+          driver.runs.load(transaction, {
+            conversationId,
+            runId: operation.input.run.id
+          }),
+          driver.runs.loadByAssistantMessageId(transaction, {
+            conversationId,
+            assistantMessageId: operation.input.run.assistantMessageId
+          })
+        ]);
+        if (runCollision || assistantCollision) {
+          throw new TypeError("Queued run identities are already reserved");
+        }
+      }
+    }
+    const reduced = reduceStore(current, operation);
     if (reduced.outcome !== "applied")
       return reduced;
-    const nextState = AgentStoredStateSchema.parse({
+    const nextHead = AgentRuntimeHeadSchema.parse({
       schemaVersion: 1,
       conversationId,
-      version: reduced.snapshot.version,
-      runs: reduced.snapshot.runs,
-      admissions: reduced.admissions
+      version: reduced.snapshot.version
     });
-    const outcome = await driver.state.compareAndSwap(transaction, {
+    const outcome = await driver.head.compareAndSwap(transaction, {
       conversationId,
       expectedVersion: current.version,
-      next: nextState,
-      recoverable: recoverableDescriptors(nextState)
+      next: nextHead
     });
     if (outcome.outcome === "conflict")
       return conflict(outcome.actualVersion);
+    if (reduced.runRecord)
+      await driver.runs.save(transaction, reduced.runRecord);
+    if (reduced.admissionReceipt) {
+      await driver.admissions.create(transaction, reduced.admissionReceipt);
+    }
     if (reduced.historyMutation) {
       await driver.history.apply(transaction, reduced.historyMutation);
     }
@@ -2481,10 +2671,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 +2690,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 +2706,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 +2808,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 +2816,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 +2834,7 @@ export {
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionEventSchema,
-  AgentAdmissionIdentitySchema,
+  AgentAdmissionReceiptSchema,
   AgentAssistantPlaceholderSchema,
   AgentCheckpointEventSchema,
   AgentControlPartSchema,
@@ -2633,6 +2866,7 @@ export {
   AgentRunStateSchema,
   AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,
+  AgentRuntimeHeadSchema,
   AgentSnapshotSchema,
   AgentSourcePartSchema,
   AgentStoreAppliedSchema,
@@ -2640,7 +2874,7 @@ export {
   AgentStoreDuplicateSchema,
   AgentStoreMutationResultSchema,
   AgentStoreNotFoundSchema,
-  AgentStoredStateSchema,
+  AgentStoredRunSchema,
   AgentTerminalEventSchema,
   AgentTerminalReasonSchema,
   AgentTextPartSchema,