stitchkit 0.65.1 → 0.66.1

package/dist/agent-runtime.js

@@ -13,6 +13,7 @@ import {
   AgentMessageSchema,
   AgentMessageStatusSchema,
   AgentOpaquePartSchema,
+  AgentProvenanceSchema,
   AgentProviderEnvelopeSchema,
   AgentReasoningPartSchema,
   AgentRecordIdSchema,
@@ -30,7 +31,7 @@ import {
   AgentUsageSchema,
   AgentUsageValueSchema,
   runStateForTerminalReason
-} from "./index-sbkyvacf.js";
+} from "./index-fhsmrzj7.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -56,6 +57,8 @@ function assistantStatus(reason) {
   }
   if (reason === "superseded")
     return "superseded";
+  if (reason === "absorbed")
+    return "superseded";
   if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
     return "interrupted";
   }
@@ -836,7 +839,12 @@ function createAgentObservability(config) {
 import { z as z4 } from "zod";
 var AgentTokenCountSchema = z4.object({
   value: z4.int().nonnegative().optional(),
-  provenance: z4.enum(["measured", "estimated", "unavailable"])
+  provenance: AgentProvenanceSchema.extract([
+    "measured",
+    "computed",
+    "estimated",
+    "unavailable"
+  ])
 });
 function completeTurn(messages) {
   if (messages[0]?.role !== "user")
@@ -947,7 +955,7 @@ async function selectAgentHistory(options) {
   return {
     messages,
     decisions,
-    totalTokens: { value: total, provenance: estimated ? "estimated" : "measured" },
+    totalTokens: { value: total, provenance: estimated ? "estimated" : "computed" },
     outcome: total > options.availableTokens ? "oversized" : removed.size > 0 ? "truncated" : "fits"
   };
 }
@@ -964,11 +972,11 @@ function composeAgentPrompt(sections) {
       const text = await section.render({ context: options.context, signal: options.signal });
       rendered.push({ name: section.name, stability: section.stability, text });
       let count;
-      if (section.estimateTokens)
-        count = await section.estimateTokens(text);
-      else if (options.estimateFallback)
-        count = await options.estimateFallback(text);
-      else
+      if (section.estimateTokens) {
+        count = AgentTokenCountSchema.parse(await section.estimateTokens(text));
+      } else if (options.estimateFallback) {
+        count = AgentTokenCountSchema.parse(await options.estimateFallback(text));
+      } else
         count = { provenance: "unavailable" };
       const value = knownValue(count);
       if (value === undefined)
@@ -978,20 +986,23 @@ function composeAgentPrompt(sections) {
       if (count.provenance === "estimated")
         estimated = true;
     }
-    const instructionTokens = unavailable ? { provenance: "unavailable" } : { value: total, provenance: estimated ? "estimated" : "measured" };
+    const instructionTokens = unavailable ? { provenance: "unavailable" } : { value: total, provenance: estimated ? "estimated" : "computed" };
     let availableHistoryTokens;
     let contextDecision = "unavailable";
     if (options.budget) {
+      if (!Number.isSafeInteger(options.budget.contextWindow) || options.budget.contextWindow < 0 || !Number.isSafeInteger(options.budget.reservedOutput) || options.budget.reservedOutput < 0) {
+        throw new TypeError("contextWindow and reservedOutput must be non-negative safe integers");
+      }
       const reserveValues = [
         options.budget.reservedOutput,
-        knownValue(options.budget.toolSchemas),
-        knownValue(options.budget.attachments),
-        knownValue(options.budget.providerOverhead),
+        knownValue(AgentTokenCountSchema.parse(options.budget.toolSchemas)),
+        knownValue(AgentTokenCountSchema.parse(options.budget.attachments)),
+        knownValue(AgentTokenCountSchema.parse(options.budget.providerOverhead)),
         knownValue(instructionTokens)
       ];
       if (reserveValues.every((value) => value !== undefined)) {
         availableHistoryTokens = Math.max(0, options.budget.contextWindow - reserveValues.reduce((sum, value) => sum + (value ?? 0), 0));
-        const historyTokens = options.historyTokens ? knownValue(options.historyTokens) : undefined;
+        const historyTokens = options.historyTokens ? knownValue(AgentTokenCountSchema.parse(options.historyTokens)) : undefined;
         if (historyTokens !== undefined) {
           if (historyTokens <= availableHistoryTokens)
             contextDecision = "fits";
@@ -1075,6 +1086,48 @@ function createRuntimeAdmissionLanes() {
   };
 }
 
+// src/agent-runtime/injection.ts
+function createAgentInjectionRegistry() {
+  const offered = new Map;
+  return {
+    offer(key, entry) {
+      const existing = offered.get(key);
+      if (!existing) {
+        offered.set(key, [entry]);
+        return;
+      }
+      if (existing.some((candidate) => candidate.input.id === entry.input.id))
+        return;
+      existing.push(entry);
+    },
+    take(key, excludeRunId) {
+      const existing = offered.get(key);
+      if (!existing)
+        return [];
+      const taken = existing.filter((candidate) => candidate.runId !== excludeRunId);
+      const kept = existing.filter((candidate) => candidate.runId === excludeRunId);
+      if (kept.length === 0)
+        offered.delete(key);
+      else
+        offered.set(key, kept);
+      return taken;
+    },
+    withdraw(key, runId) {
+      const existing = offered.get(key);
+      if (!existing)
+        return;
+      const kept = existing.filter((candidate) => candidate.runId !== runId);
+      if (kept.length === 0)
+        offered.delete(key);
+      else
+        offered.set(key, kept);
+    },
+    clear() {
+      offered.clear();
+    }
+  };
+}
+
 // src/agent-runtime/run-execution.ts
 import {
   stepCountIs,
@@ -1096,16 +1149,33 @@ function appliedSnapshot(result, operation) {
     return result.snapshot;
   throw new AgentRuntimeConflictError(operation);
 }
-function canonicalTerminal(snapshot, runId, retainedAssistant) {
+function viewOfSnapshot(snapshot, runId, retainedAssistant) {
   const run = snapshot.runs.find((candidate) => candidate.id === runId);
+  const assistant = snapshot.messages.find((message) => message.id === run?.assistantMessageId) ?? retainedAssistant;
+  return {
+    snapshotVersion: snapshot.version,
+    conversationId: snapshot.conversationId,
+    ...run && { run },
+    ...assistant && { assistant }
+  };
+}
+function viewOfRun(view, conversationId) {
+  return {
+    snapshotVersion: view.snapshotVersion,
+    conversationId,
+    run: view.run,
+    ...view.assistant && { assistant: view.assistant }
+  };
+}
+function canonicalTerminal(view) {
+  const { run, assistant } = view;
   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 !== assistantStatus(run.terminalReason)) {
+  if (view.conversationId !== run.conversationId || !assistant || assistant.id !== run.assistantMessageId || assistant.conversationId !== run.conversationId || assistant.runId !== run.id || assistant.role !== "assistant" || assistant.status !== assistantStatus(run.terminalReason)) {
     throw new AgentRuntimeConflictError("terminal result projection");
   }
   return {
-    snapshot,
+    snapshotVersion: view.snapshotVersion,
     run,
     assistant,
     reason: run.terminalReason,
@@ -1136,9 +1206,10 @@ function interruptedCandidate(candidate, run, now) {
 function canRetryTerminal(current, previous, runtimeEpoch) {
   return (current.state === "running" || current.state === "interrupt_requested") && current.ownerId === runtimeEpoch && current.fencingToken === previous.fencingToken;
 }
+var TERMINAL_COMMIT_ATTEMPTS = 32;
 async function commitAgentRunTerminal(input) {
   let candidate = input.candidate;
-  while (true) {
+  for (let attempt = 0;attempt < TERMINAL_COMMIT_ATTEMPTS; attempt += 1) {
     const committed = await input.store.commitRunTerminal({
       conversationId: candidate.run.conversationId,
       runId: candidate.run.id,
@@ -1150,16 +1221,22 @@ async function commitAgentRunTerminal(input) {
       assistant: candidate.assistant,
       reason: candidate.reason,
       ...candidate.policyName && { policyName: candidate.policyName },
-      ...candidate.usage && { usage: candidate.usage }
+      ...candidate.usage && { usage: candidate.usage },
+      ...candidate.absorb?.length && { absorb: candidate.absorb }
     });
     if (committed.outcome === "applied") {
-      const terminal2 = canonicalTerminal(committed.snapshot, candidate.run.id);
+      const terminal2 = canonicalTerminal(viewOfSnapshot(committed.snapshot, candidate.run.id));
       if (!terminal2)
         throw new AgentRuntimeConflictError("terminal result projection");
-      return { ...terminal2, committedByCaller: true };
+      const absorbed = committed.snapshot.runs.filter((run) => run.absorbedIntoRunId === candidate.run.id);
+      return {
+        ...terminal2,
+        committedByCaller: true,
+        ...absorbed.length > 0 && { absorbed }
+      };
     }
     if (committed.outcome === "duplicate") {
-      const terminal2 = canonicalTerminal(committed.snapshot, candidate.run.id, committed.assistant);
+      const terminal2 = canonicalTerminal(viewOfSnapshot(committed.snapshot, candidate.run.id, committed.assistant));
       if (!terminal2)
         throw new AgentRuntimeConflictError("terminal result projection");
       return terminal2;
@@ -1167,16 +1244,20 @@ async function commitAgentRunTerminal(input) {
     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);
+    const latest = await input.store.loadRun({
+      conversationId: candidate.run.conversationId,
+      runId: candidate.run.id
+    });
+    const terminal = latest ? canonicalTerminal(viewOfRun(latest, candidate.run.conversationId)) : undefined;
     if (terminal)
       return terminal;
-    const current = latest.runs.find((run) => run.id === candidate.run.id);
+    const current = latest?.run;
     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 };
   }
+  throw new AgentRuntimeConflictError("terminal commit");
 }
 
 // src/agent-runtime/runtime-internals.ts
@@ -1285,7 +1366,7 @@ function unknownUsage() {
   };
 }
 function normalizeSdkUsage(value) {
-  const reported = (tokens) => tokens === undefined ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
+  const reported = (tokens) => tokens === undefined || !Number.isSafeInteger(tokens) || tokens < 0 ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
   return {
     inputTokens: reported(value.inputTokens),
     outputTokens: reported(value.outputTokens),
@@ -1329,11 +1410,36 @@ function createRunExecutor(dependencies) {
     now,
     checkpointEveryEvents,
     maxSteps,
-    idleTimeoutMs
+    idleTimeoutMs,
+    injection
   } = dependencies;
   return async function executeRun(input) {
-    const queuedSnapshot = await config.store.loadSnapshot(input.acceptedRun.conversationId);
-    const queuedRun = findRun(queuedSnapshot.runs, input.acceptedRun.id);
+    injection?.withdraw(input.key, input.acceptedRun.id);
+    const queued = await config.store.loadRun({
+      conversationId: input.acceptedRun.conversationId,
+      runId: input.acceptedRun.id
+    });
+    if (!queued)
+      throw new AgentRuntimeConflictError("run lookup");
+    if (queued.run.terminalReason === "absorbed") {
+      const absorbing = queued.run.absorbedIntoRunId ? await config.store.loadRun({
+        conversationId: queued.run.conversationId,
+        runId: queued.run.absorbedIntoRunId
+      }) : undefined;
+      if (!absorbing?.assistant || !absorbing.run.terminalReason) {
+        throw new AgentRuntimeConflictError("absorbed run resolution");
+      }
+      return {
+        run: absorbing.run,
+        message: absorbing.assistant,
+        reason: absorbing.run.terminalReason,
+        snapshotVersion: absorbing.snapshotVersion,
+        ...absorbing.run.terminalPolicyName && {
+          policyName: absorbing.run.terminalPolicyName
+        }
+      };
+    }
+    const queuedRun = queued.run;
     const acquired = appliedSnapshot(await config.store.acquireRun({
       conversationId: queuedRun.conversationId,
       runId: queuedRun.id,
@@ -1385,7 +1491,9 @@ function createRunExecutor(dependencies) {
       assistant
     }), "assistant draft");
     run = findRun(snapshot.runs, run.id);
+    let observedVersion = snapshot.version;
     const parts = [];
+    const absorbed = new Map;
     let eventCount = 0;
     let sequence = 0;
     let terminalReason = "success";
@@ -1436,6 +1544,7 @@ function createRunExecutor(dependencies) {
         assistant,
         usage: statedUsage(usage)
       }), "assistant checkpoint");
+      observedVersion = snapshot.version;
       run = findRun(snapshot.runs, run.id);
       const checkpointMetrics = {
         partial: true,
@@ -1445,10 +1554,10 @@ function createRunExecutor(dependencies) {
       };
       await publish({
         type: "assistant-checkpoint",
-        eventId: agentDurableEventId("assistant-checkpoint", run.id, snapshot.version),
+        eventId: agentDurableEventId("assistant-checkpoint", run.id, observedVersion),
         conversationId: run.conversationId,
         runId: run.id,
-        snapshotVersion: snapshot.version,
+        snapshotVersion: observedVersion,
         message: assistant,
         metrics: checkpointMetrics,
         emittedAt: now().toISOString()
@@ -1462,6 +1571,7 @@ function createRunExecutor(dependencies) {
           signal: executionSignal
         });
         snapshot = compacted.snapshot;
+        observedVersion = snapshot.version;
         run = findRun(snapshot.runs, run.id);
         if (compacted.usage)
           usage = addUsage(usage, compacted.usage);
@@ -1469,8 +1579,11 @@ function createRunExecutor(dependencies) {
       const assertCurrent = async () => {
         if (executionSignal.aborted)
           return "run_interrupted";
-        const current = await config.store.loadSnapshot(run.conversationId);
-        const currentRun = current.runs.find((candidate) => candidate.id === run.id);
+        const current = await config.store.loadRun({
+          conversationId: run.conversationId,
+          runId: run.id
+        });
+        const currentRun = current?.run;
         if (!currentRun || currentRun.ownerId !== runtimeEpoch)
           return "stale_run";
         if (currentRun.fencingToken !== run.fencingToken)
@@ -1531,6 +1644,20 @@ function createRunExecutor(dependencies) {
         carriedSystem = detailed.system;
         return [...detailed.messages];
       };
+      const projectInputs = async (source) => {
+        if (config.history?.project)
+          return config.history.project(source);
+        const detailed = await projectAgentHistoryDetailed(source, {
+          ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
+          ...config.history?.unresolvedFile && {
+            unresolvedFile: config.history.unresolvedFile
+          },
+          ...config.history?.interruptedAssistant && {
+            interruptedAssistant: config.history.interruptedAssistant
+          }
+        });
+        return [...detailed.messages];
+      };
       const history = await projectHistory(snapshot);
       const withCarriedSystem = (instructions) => {
         if (carriedSystem.length === 0)
@@ -1558,6 +1685,19 @@ function createRunExecutor(dependencies) {
           return stopped;
         });
       }
+      const takeInjectedMessages = async () => {
+        const taken = injection?.take(input.key, run.id) ?? [];
+        if (taken.length === 0)
+          return [];
+        const messages = [];
+        for (const entry of taken) {
+          messages.push(...await projectInputs([entry.input]));
+          const ids = absorbed.get(entry.runId) ?? [];
+          ids.push(entry.input.id);
+          absorbed.set(entry.runId, ids);
+        }
+        return messages;
+      };
       const result = streamText({
         model: selectedModel.model,
         tools,
@@ -1566,8 +1706,18 @@ function createRunExecutor(dependencies) {
         abortSignal: executionSignal,
         maxRetries: 0,
         stopWhen: stopConditions,
-        ...config.loop?.prepareStep && {
-          prepareStep: (options) => config.loop?.prepareStep?.({ ...options, ...runtimeContext })
+        ...(config.loop?.prepareStep || injection) && {
+          prepareStep: async (options) => {
+            const prepared = await config.loop?.prepareStep?.({
+              ...options,
+              ...runtimeContext
+            });
+            const injected = await takeInjectedMessages();
+            if (injected.length === 0)
+              return prepared;
+            const base = prepared?.messages ?? options.messages;
+            return { ...prepared, messages: [...base, ...injected] };
+          }
         }
       });
       for await (const part of result.stream) {
@@ -1818,11 +1968,14 @@ function createRunExecutor(dependencies) {
         terminalReason = abortTerminalReason(executionSignal);
     } catch (error) {
       internalCause = error;
-      const latest = await config.store.loadSnapshot(run.conversationId);
-      const latestRun = latest.runs.find((candidate) => candidate.id === run.id);
+      const latest = await config.store.loadRun({
+        conversationId: run.conversationId,
+        runId: run.id
+      });
+      const latestRun = latest?.run;
       const durableInterrupt = latestRun?.ownerId === runtimeEpoch && latestRun.state === "interrupt_requested";
-      if (durableInterrupt && latestRun) {
-        snapshot = latest;
+      if (durableInterrupt && latest && latestRun) {
+        observedVersion = latest.snapshotVersion;
         run = latestRun;
       }
       if (isToolExecutionControlError(error) || executionSignal.aborted || durableInterrupt) {
@@ -1875,19 +2028,25 @@ function createRunExecutor(dependencies) {
           assistant,
           reason: terminalReason,
           ...terminalPolicyName && { policyName: terminalPolicyName },
-          usage: spent
+          usage: spent,
+          ...absorbed.size > 0 && runStateForTerminalReason(terminalReason) === "completed" && {
+            absorb: [...absorbed].map(([runId, inputMessageIds]) => ({
+              runId,
+              inputMessageIds
+            }))
+          }
         },
         now
       });
     } catch (error) {
       emitSpend({
-        eventId: unsettledEventId(snapshot.version),
+        eventId: unsettledEventId(observedVersion),
         state: run.state,
         reason: terminalReason
       });
       throw error;
     }
-    snapshot = terminal.snapshot;
+    observedVersion = terminal.snapshotVersion;
     run = terminal.run;
     assistant = terminal.assistant;
     terminalReason = terminal.reason;
@@ -1899,17 +2058,28 @@ function createRunExecutor(dependencies) {
       ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
     } : undefined;
     emitSpend({
-      eventId: terminal.committedByCaller ? agentDurableEventId("terminal", run.id, snapshot.version) : unsettledEventId(snapshot.version),
+      eventId: terminal.committedByCaller ? agentDurableEventId("terminal", run.id, observedVersion) : unsettledEventId(observedVersion),
       state: run.state,
       reason: terminalReason
     });
+    for (const settled of terminal.absorbed ?? []) {
+      await publish({
+        type: "run-state",
+        eventId: agentDurableEventId("run-state", settled.id, observedVersion),
+        conversationId: settled.conversationId,
+        runId: settled.id,
+        snapshotVersion: observedVersion,
+        state: settled.state,
+        emittedAt: now().toISOString()
+      });
+    }
     if (terminalMetrics) {
       await publish({
         type: "terminal",
-        eventId: agentDurableEventId("terminal", run.id, snapshot.version),
+        eventId: agentDurableEventId("terminal", run.id, observedVersion),
         conversationId: run.conversationId,
         runId: run.id,
-        snapshotVersion: snapshot.version,
+        snapshotVersion: observedVersion,
         reason: terminalReason,
         ...terminalPolicyName && { policyName: terminalPolicyName },
         message: assistant,
@@ -1921,7 +2091,7 @@ function createRunExecutor(dependencies) {
       run,
       message: assistant,
       reason: terminalReason,
-      snapshotVersion: snapshot.version,
+      snapshotVersion: observedVersion,
       ...terminalMetrics && { metrics: terminalMetrics },
       ...terminalPolicyName && { policyName: terminalPolicyName }
     };
@@ -1936,6 +2106,8 @@ function createAgentRuntime(config) {
   const now = config.now ?? (() => new Date);
   const runtimeEpoch = generateId();
   const admissionLanes = createRuntimeAdmissionLanes();
+  const injectionPossible = typeof config.runs?.inputPolicy === "function" || config.runs?.inputPolicy === "inject";
+  const injection = injectionPossible ? createAgentInjectionRegistry() : undefined;
   const reserveAdmission = admissionLanes.reserve;
   const settleAdmission = admissionLanes.settle;
   const waitForAdmissionAcceptances = admissionLanes.waitForAcceptances;
@@ -1976,7 +2148,8 @@ function createAgentRuntime(config) {
     now,
     checkpointEveryEvents,
     maxSteps,
-    ...idleTimeoutMs !== undefined && { idleTimeoutMs }
+    ...idleTimeoutMs !== undefined && { idleTimeoutMs },
+    ...injection && { injection }
   });
   let admissionClosed = false;
   const closedError = () => new Error("[stitchkit] agent runtime is closed and admits no further work");
@@ -2033,8 +2206,13 @@ function createAgentRuntime(config) {
     const handedOff = beginAdmission();
     (async () => {
       try {
-        const snapshot = await config.store.loadSnapshot(rawInput.conversationId);
-        const recoveredRun = findRun(snapshot.runs, rawInput.runId);
+        const recovered = await config.store.loadRun({
+          conversationId: rawInput.conversationId,
+          runId: rawInput.runId
+        });
+        if (!recovered)
+          throw new AgentRuntimeConflictError("run lookup");
+        const recoveredRun = recovered.run;
         if (recoveredRun.state !== "queued") {
           throw new Error("Only a queued recovered agent run can be resumed");
         }
@@ -2044,7 +2222,12 @@ function createAgentRuntime(config) {
           policy: "queue",
           create: (signal) => ({
             runId: recoveredRun.id,
-            execute: () => executeRun({ acceptedRun: recoveredRun, context, signal })
+            execute: () => executeRun({
+              acceptedRun: recoveredRun,
+              context,
+              signal,
+              key: rawInput.conversationKey ?? rawInput.conversationId
+            })
           })
         });
         ticket.accepted.catch(() => {
@@ -2134,7 +2317,10 @@ function createAgentRuntime(config) {
       currentConversationTickets.set(input.idempotencyKey, publicTicket);
       if (!conversationTickets)
         tickets.set(input.conversationId, currentConversationTickets);
+      let offeredRunId;
       const forgetTicket = () => {
+        if (offeredRunId !== undefined)
+          injection?.withdraw(key, offeredRunId);
         if (currentConversationTickets.get(input.idempotencyKey) !== publicTicket)
           return;
         currentConversationTickets.delete(input.idempotencyKey);
@@ -2246,6 +2432,10 @@ function createAgentRuntime(config) {
             }
             return;
           }
+          if (policy === "inject") {
+            offeredRunId = acceptedRun.id;
+            injection?.offer(key, { runId: acceptedRun.id, input: acceptedInput });
+          }
           if (reservation && !reservation.shouldSchedule) {
             reservation.admission.completion.promise.then(outerResult.resolve, outerResult.reject);
             return;
@@ -2258,7 +2448,7 @@ function createAgentRuntime(config) {
                 await waitForAdmissionAcceptances(reservation.lane);
               return {
                 runId: acceptedRun.id,
-                execute: () => executeRun({ acceptedRun, context, signal })
+                execute: () => executeRun({ acceptedRun, context, signal, key })
               };
             }
           });
@@ -2294,12 +2484,16 @@ function createAgentRuntime(config) {
     },
     resume,
     async interrupt(input) {
-      const snapshot = await config.store.loadSnapshot(input.conversationId);
-      const run = findRun(snapshot.runs, input.runId);
+      const view = await config.store.loadRun({
+        conversationId: input.conversationId,
+        runId: input.runId
+      });
+      if (!view)
+        throw new AgentRuntimeConflictError("run lookup");
       const requested = await config.store.requestRunInterrupt({
         conversationId: input.conversationId,
         runId: input.runId,
-        expectedRevision: run.revision
+        expectedRevision: view.run.revision
       });
       if (requested.outcome === "applied") {
         const interruptedRun = findRun(requested.snapshot.runs, input.runId);
@@ -2342,8 +2536,8 @@ function createAgentRuntime(config) {
           const handedOff = beginAdmission();
           try {
             if (item.run.state === "queued") {
-              const snapshot = await config.store.loadSnapshot(item.conversationId);
-              const blockedByAcquiredPredecessor = snapshot.runs.some((run) => run.id !== item.run.id && (run.state === "running" || run.state === "interrupt_requested"));
+              const active = await config.store.listActiveRuns(item.conversationId);
+              const blockedByAcquiredPredecessor = active.some((run) => run.id !== item.run.id && (run.state === "running" || run.state === "interrupt_requested"));
               if (blockedByAcquiredPredecessor) {
                 outcomes.push({
                   conversationId: item.conversationId,
@@ -2430,6 +2624,7 @@ function createAgentRuntime(config) {
       assertCloseBudgets(options);
       admissionClosed = true;
       const startedAt = performance.now();
+      injection?.clear();
       const stranded = await drainAdmissions(options.forceTimeoutMs);
       const spent = Math.max(0, Math.round(performance.now() - startedAt));
       const remainingBudget = (value) => value === undefined ? undefined : Math.max(0, value - spent);
@@ -2472,6 +2667,11 @@ var AgentStoreMutationResultSchema = z6.discriminatedUnion("outcome", [
   AgentStoreConflictSchema,
   AgentStoreNotFoundSchema
 ]);
+var AgentRunViewSchema = z6.object({
+  snapshotVersion: AgentRecordVersionSchema,
+  run: AgentRunSchema,
+  assistant: AgentMessageSchema.optional()
+});
 var AcceptInputAndAssignRunSchema = z6.object({
   idempotencyKey: z6.string().min(1),
   expectedVersion: AgentRecordVersionSchema.optional(),
@@ -2503,7 +2703,11 @@ var CommitRunTerminalSchema = z6.object({
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
   policyName: z6.string().min(1).optional(),
-  usage: AgentUsageSchema.optional()
+  usage: AgentUsageSchema.optional(),
+  absorb: z6.array(z6.object({
+    runId: AgentRecordIdSchema,
+    inputMessageIds: z6.array(AgentRecordIdSchema).min(1)
+  })).min(1).optional()
 });
 var RequestRunInterruptSchema = z6.object({
   conversationId: AgentRecordIdSchema,
@@ -2665,9 +2869,9 @@ function applied(current, input, effects) {
       runs: input.runs ?? current.runs,
       messages: input.messages ?? current.messages
     }),
-    ...effects?.runRecord && { runRecord: effects.runRecord },
+    ...effects?.runRecords?.length && { runRecords: effects.runRecords },
     ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
-    ...effects?.historyMutation && { historyMutation: effects.historyMutation }
+    ...effects?.historyMutations?.length && { historyMutations: effects.historyMutations }
   };
 }
 function reduceStore(current, operation) {
@@ -2701,12 +2905,9 @@ function reduceStore(current, operation) {
       messages: [...current.messages, input.input],
       runs: coalescedRun ? replaceRun(current.runs, assignedRun) : [...current.runs, assignedRun]
     }, {
-      runRecord: AgentStoredRunSchema.parse({
-        schemaVersion: 1,
-        run: assignedRun
-      }),
+      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: assignedRun })],
       admissionReceipt,
-      historyMutation: { type: "admit", input: input.input }
+      historyMutations: [{ type: "admit", input: input.input }]
     });
   }
   const conversationId = operation.input.conversationId;
@@ -2728,7 +2929,7 @@ function reduceStore(current, operation) {
       updatedAt: new Date().toISOString()
     });
     return applied(current, { runs: replaceRun(current.runs, next) }, {
-      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
+      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
     });
   }
   if (operation.type === "checkpoint" && run) {
@@ -2746,8 +2947,8 @@ function reduceStore(current, operation) {
       runs: replaceRun(current.runs, next),
       messages: replaceMessage(current.messages, input.assistant)
     }, {
-      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next }),
-      historyMutation: { type: "upsert-assistant", message: input.assistant }
+      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })],
+      historyMutations: [{ type: "upsert-assistant", message: input.assistant }]
     });
   }
   if (operation.type === "interrupt" && run) {
@@ -2761,7 +2962,7 @@ function reduceStore(current, operation) {
       updatedAt: new Date().toISOString()
     });
     return applied(current, { runs: replaceRun(current.runs, next) }, {
-      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })
+      runRecords: [AgentStoredRunSchema.parse({ schemaVersion: 1, run: next })]
     });
   }
   if (operation.type === "recover" && run) {
@@ -2799,42 +3000,82 @@ function reduceStore(current, operation) {
         runs: replaceRun(current.runs, next),
         messages: replaceMessage(current.messages, assistant)
       }, {
-        runRecord: AgentStoredRunSchema.parse({
-          schemaVersion: 1,
-          run: next,
-          terminalAssistant: assistant
-        }),
-        historyMutation: { type: "upsert-assistant", message: assistant }
+        runRecords: [
+          AgentStoredRunSchema.parse({
+            schemaVersion: 1,
+            run: next,
+            terminalAssistant: assistant
+          })
+        ],
+        historyMutations: [{ type: "upsert-assistant", message: assistant }]
       });
     }
     return applied(current, { runs: replaceRun(current.runs, next) }, {
-      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: 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: replaceRun(current.runs, next),
+      runs,
       messages: replaceMessage(current.messages, input.assistant)
     }, {
-      runRecord: AgentStoredRunSchema.parse({
-        schemaVersion: 1,
-        run: next,
-        terminalAssistant: input.assistant
-      }),
-      historyMutation: { type: "upsert-assistant", message: 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") {
@@ -2862,11 +3103,13 @@ function reduceStore(current, operation) {
       ...current.messages.slice(first + positions.length)
     ];
     return applied(current, { messages }, {
-      historyMutation: {
-        type: "replace-compacted-range",
-        replacedMessageIds: input.replacedMessageIds,
-        summary: input.summary
-      }
+      historyMutations: [
+        {
+          type: "replace-compacted-range",
+          replacedMessageIds: input.replacedMessageIds,
+          summary: input.summary
+        }
+      ]
     });
   }
   return { outcome: "not_found" };
@@ -2912,6 +3155,37 @@ function createAgentRuntimeStore(driver) {
     });
     return snapshotOf(head, messages, mergeRunRecords(activeRecords, referencedRecords));
   });
+  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 }
+    });
+  });
+  const listActiveRuns = (conversationId) => driver.transaction(async (transaction) => {
+    const records = await driver.runs.listActive(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 runs.sort((left, right) => left.createdAt === right.createdAt ? left.id.localeCompare(right.id) : left.createdAt < right.createdAt ? -1 : 1);
+  });
   const mutate = (operation) => driver.transaction(async (transaction) => {
     const conversationId = operationConversationId(operation);
     const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.input.runId;
@@ -2941,17 +3215,25 @@ function createAgentRuntimeStore(driver) {
         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: duplicateReceipt.runId,
-        assistantMessageId: duplicateReceipt.assistantMessageId,
-        run: duplicateRecord.run,
-        ...duplicateRecord.terminalAssistant && {
-          assistant: duplicateRecord.terminalAssistant
+        runId: canonical.run.id,
+        assistantMessageId: canonical.run.assistantMessageId,
+        run: canonical.run,
+        ...canonical.terminalAssistant && {
+          assistant: canonical.terminalAssistant
         },
-        snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord]))
+        snapshot: snapshotOf(head, messages, mergeRunRecords(records, [duplicateRecord], answering ? [answering] : []))
       };
     }
     if (operation.type === "accept") {
@@ -2993,18 +3275,21 @@ function createAgentRuntimeStore(driver) {
     });
     if (outcome.outcome === "conflict")
       return conflict(outcome.actualVersion);
-    if (reduced.runRecord)
-      await driver.runs.save(transaction, reduced.runRecord);
+    for (const record of reduced.runRecords ?? []) {
+      await driver.runs.save(transaction, record);
+    }
     if (reduced.admissionReceipt) {
       await driver.admissions.create(transaction, reduced.admissionReceipt);
     }
-    if (reduced.historyMutation) {
-      await driver.history.apply(transaction, reduced.historyMutation);
+    for (const mutation of reduced.historyMutations ?? []) {
+      await driver.history.apply(transaction, mutation);
     }
     return { outcome: "applied", snapshot: reduced.snapshot };
   });
   return {
     loadSnapshot,
+    loadRun,
+    listActiveRuns,
     acceptInputAndAssignRun: (input) => mutate({
       type: "accept",
       input: AcceptInputAndAssignRunSchema.parse(input)
@@ -3213,6 +3498,7 @@ export {
   AgentModelDescriptorSchema,
   AgentModelRegistrySnapshotSchema,
   AgentOpaquePartSchema,
+  AgentProvenanceSchema,
   AgentProviderEnvelopeSchema,
   AgentReasoningDeltaEventSchema,
   AgentReasoningEndEventSchema,
@@ -3229,6 +3515,7 @@ export {
   AgentRunStateEventSchema,
   AgentRunStateSchema,
   AgentRunTerminalEventSchema,
+  AgentRunViewSchema,
   AgentRuntimeConflictError,
   AgentRuntimeEventCursorSchema,
   AgentRuntimeEventSchema,