stitchkit 0.61.0 → 0.63.0

package/dist/agent-runtime.js

@@ -29,7 +29,7 @@ import {
   AgentToolResultPartSchema,
   AgentUsageSchema,
   AgentUsageValueSchema
-} from "./index-vtjgx3vv.js";
+} from "./index-b1k33127.js";
 import"./index-6djpbnda.js";
 import"./index-cby4ar3v.js";
 import {
@@ -45,14 +45,29 @@ import {
 import"./index-smpbdg6k.js";
 import"./index-xxye8j3k.js";
 
+// src/agent-runtime/terminal-status.ts
+function isSpeakableAssistantStatus(status) {
+  return status === "completed" || status === "interrupted" || status === "committed";
+}
+function assistantStatus(reason) {
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
+    return "completed";
+  }
+  if (reason === "superseded")
+    return "superseded";
+  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
+    return "interrupted";
+  }
+  return "failed";
+}
+
 // src/agent-runtime/compaction.ts
 function providerValidTurn(messages) {
   if (messages[0]?.role !== "user")
     return false;
   const assistant = messages.find((message) => message.role === "assistant");
-  if (!assistant || assistant.status === "streaming" || assistant.status === "failed") {
+  if (!assistant || !isSpeakableAssistantStatus(assistant.status))
     return false;
-  }
   const calls = new Set(assistant.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
   const results = new Set(assistant.parts.filter((part) => part.type === "tool-result").map((part) => part.callId));
   return [...calls].every((callId) => results.has(callId)) && [...results].every((callId) => calls.has(callId));
@@ -226,6 +241,8 @@ function createAgentSessionCoordinator() {
       };
       if (input.policy === "interrupt")
         lane.active?.controller.abort("user-interrupt");
+      if (input.policy === "supersede")
+        lane.active?.controller.abort("supersede");
       lane.queue.push(pending);
       startNext(input.key, lane);
       return { accepted: accepted.promise, result: result.promise };
@@ -428,11 +445,34 @@ function textContent(parts) {
   return parts.filter((part) => part.type === "text").map((part) => part.text).join(`
 `);
 }
+function unrepresented(parts, rendered) {
+  const missing = new Set;
+  for (const part of parts) {
+    if (!rendered.has(part.type))
+      missing.add(part.type);
+  }
+  return [...missing];
+}
+function decide(message, action, reason, rendered) {
+  if (action === "omitted" || !rendered)
+    return { messageId: message.id, action, reason };
+  const omittedParts = unrepresented(message.parts, rendered);
+  return {
+    messageId: message.id,
+    action,
+    reason,
+    ...omittedParts.length > 0 && { omittedParts }
+  };
+}
+var INTERRUPTION_NOTE = "[interrupted: this turn was cut off before it finished]";
 async function userMessage(message, options) {
+  const rendered = new Set;
   const text = textContent(message.parts);
   const content = [];
-  if (text)
+  if (text) {
     content.push({ type: "text", text });
+    rendered.add("text");
+  }
   for (const part of message.parts) {
     if (part.type !== "file")
       continue;
@@ -443,6 +483,7 @@ async function userMessage(message, options) {
         mediaType: part.mediaType,
         ...part.filename && { filename: part.filename }
       });
+      rendered.add("file");
       continue;
     }
     const fallback = options.unresolvedFile ?? "omit";
@@ -455,24 +496,29 @@ async function userMessage(message, options) {
         type: "text",
         text: described ? `[attachment: ${described}]` : "[attachment]"
       });
+      rendered.add("file");
     }
   }
   if (content.length === 0)
-    return;
-  return modelMessageSchema.parse({ role: "user", content });
+    return { rendered };
+  return { message: modelMessageSchema.parse({ role: "user", content }), rendered };
 }
-function assistantMessages(message) {
+function assistantMessages(message, interrupted) {
+  const rendered = new Set;
   const assistantContent = [];
   const toolContent = [];
   for (const part of message.parts) {
-    if (part.type === "text")
+    if (part.type === "text") {
       assistantContent.push({ type: "text", text: part.text });
+      rendered.add("text");
+    }
     if (part.type === "reasoning") {
       assistantContent.push({
         type: "reasoning",
         text: part.text,
         ...part.provider && { providerOptions: providerOptions(part.provider) }
       });
+      rendered.add("reasoning");
     }
     if (part.type === "tool-call") {
       assistantContent.push({
@@ -482,6 +528,7 @@ function assistantMessages(message) {
         input: part.input,
         ...part.provider && { providerOptions: providerOptions(part.provider) }
       });
+      rendered.add("tool-call");
     }
     if (part.type === "tool-result") {
       const output = part.outcome === "success" ? { type: "json", value: part.output ?? null } : { type: "error-json", value: part.output ?? { message: part.outcome } };
@@ -491,8 +538,13 @@ function assistantMessages(message) {
         toolName: part.toolName,
         output
       });
+      rendered.add("tool-result");
     }
   }
+  if (interrupted && (assistantContent.length > 0 || toolContent.length > 0)) {
+    assistantContent.push({ type: "text", text: INTERRUPTION_NOTE });
+    rendered.add("control");
+  }
   const messages = [];
   if (assistantContent.length > 0) {
     messages.push(modelMessageSchema.parse({ role: "assistant", content: assistantContent }));
@@ -500,7 +552,22 @@ function assistantMessages(message) {
   if (toolContent.length > 0) {
     messages.push(modelMessageSchema.parse({ role: "tool", content: toolContent }));
   }
-  return messages;
+  return { messages, rendered };
+}
+function interruptedSystemNote(message) {
+  const rendered = new Set;
+  const text = textContent(message.parts);
+  if (!text)
+    return { rendered };
+  rendered.add("text");
+  rendered.add("control");
+  return {
+    message: modelMessageSchema.parse({
+      role: "system",
+      content: `[interrupted] partial response: ${text}`
+    }),
+    rendered
+  };
 }
 function completeToolChronology(message) {
   const calls = new Set(message.parts.filter((part) => part.type === "tool-call").map((part) => part.callId));
@@ -510,20 +577,25 @@ function completeToolChronology(message) {
 async function projectAgentHistoryDetailed(messages, options = {}) {
   const projected = [];
   const decisions = [];
+  const interruptedRule = options.interruptedAssistant ?? "assistant-marked";
   let observedUser = false;
   for (const message of messages) {
+    if (message.status === "superseded") {
+      decisions.push(decide(message, "omitted", "superseded"));
+      continue;
+    }
     if (message.status === "streaming" || message.status === "failed") {
-      decisions.push({ messageId: message.id, action: "omitted", reason: "draft-or-failed" });
+      decisions.push(decide(message, "omitted", "draft-or-failed"));
       continue;
     }
     if (message.role === "user") {
       const user = await userMessage(message, options);
       observedUser = true;
-      if (user) {
-        projected.push(user);
-        decisions.push({ messageId: message.id, action: "projected", reason: "projected" });
+      if (user.message) {
+        projected.push(user.message);
+        decisions.push(decide(message, "projected", "projected", user.rendered));
       } else {
-        decisions.push({ messageId: message.id, action: "omitted", reason: "empty" });
+        decisions.push(decide(message, "omitted", "empty"));
       }
       continue;
     }
@@ -531,9 +603,9 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
       const content = textContent(message.parts);
       if (content) {
         projected.push(modelMessageSchema.parse({ role: "system", content }));
-        decisions.push({ messageId: message.id, action: "projected", reason: "projected" });
+        decisions.push(decide(message, "projected", "projected", new Set(["text"])));
       } else {
-        decisions.push({ messageId: message.id, action: "omitted", reason: "empty" });
+        decisions.push(decide(message, "omitted", "empty"));
       }
       continue;
     }
@@ -541,31 +613,34 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
       if (options.leadingAssistant === "error") {
         throw new Error(`Assistant message ${message.id} precedes the first user message`);
       }
-      decisions.push({
-        messageId: message.id,
-        action: "omitted",
-        reason: "leading-assistant"
-      });
+      decisions.push(decide(message, "omitted", "leading-assistant"));
+      continue;
+    }
+    const interrupted = message.status === "interrupted";
+    if (interrupted && interruptedRule === "omit") {
+      decisions.push(decide(message, "omitted", "interrupted"));
+      continue;
+    }
+    if (interrupted && interruptedRule === "system-note") {
+      const note = interruptedSystemNote(message);
+      if (note.message) {
+        projected.push(note.message);
+        decisions.push(decide(message, "projected", "projected", note.rendered));
+      } else {
+        decisions.push(decide(message, "omitted", "empty"));
+      }
       continue;
     }
     if (!completeToolChronology(message)) {
       if (options.incompleteToolTurn === "error") {
         throw new Error(`Assistant message ${message.id} has incomplete tool chronology`);
       }
-      decisions.push({
-        messageId: message.id,
-        action: "omitted",
-        reason: "incomplete-tool-turn"
-      });
+      decisions.push(decide(message, "omitted", "incomplete-tool-turn"));
       continue;
     }
-    const assistant = assistantMessages(message);
-    projected.push(...assistant);
-    decisions.push({
-      messageId: message.id,
-      action: assistant.length > 0 ? "projected" : "omitted",
-      reason: assistant.length > 0 ? "projected" : "empty"
-    });
+    const assistant = assistantMessages(message, interrupted);
+    projected.push(...assistant.messages);
+    decisions.push(assistant.messages.length > 0 ? decide(message, "projected", "projected", assistant.rendered) : decide(message, "omitted", "empty"));
   }
   return { messages: projected, decisions };
 }
@@ -786,20 +861,21 @@ async function selectAgentHistory(options) {
   if (!Number.isSafeInteger(keepRecentTurns) || keepRecentTurns < 0) {
     throw new TypeError("keepRecentTurns must be a non-negative safe integer");
   }
+  const spoken = options.messages.filter((message) => message.status !== "superseded");
   const counts = new Map;
   let total = 0;
   let estimated = false;
-  for (const message of options.messages) {
+  for (const message of spoken) {
     const count = AgentTokenCountSchema.parse(await options.estimateMessage(message));
     counts.set(message.id, count);
     const value = knownValue(count);
     if (value === undefined) {
       return {
-        messages: [...options.messages],
+        messages: [...spoken],
         decisions: options.messages.map((candidate) => ({
           messageId: candidate.id,
-          action: "kept",
-          reason: "token-count-unavailable",
+          action: candidate.status === "superseded" ? "removed" : "kept",
+          reason: candidate.status === "superseded" ? "superseded" : "token-count-unavailable",
           tokens: counts.get(candidate.id) ?? { provenance: "unavailable" }
         })),
         totalTokens: { provenance: "unavailable" },
@@ -810,7 +886,7 @@ async function selectAgentHistory(options) {
     if (count.provenance === "estimated")
       estimated = true;
   }
-  const turns = budgetTurns(options.messages);
+  const turns = budgetTurns(spoken);
   const completeIndexes = turns.map((turn, index) => ({ turn, index })).filter(({ turn }) => turn.complete && !turn.protectedSystem).map(({ index }) => index);
   const protectedRecent = new Set(completeIndexes.slice(-keepRecentTurns));
   const removed = new Set;
@@ -823,8 +899,16 @@ async function selectAgentHistory(options) {
       total -= knownValue(counts.get(message.id) ?? { provenance: "unavailable" }) ?? 0;
     }
   }
-  const messages = options.messages.filter((message) => !removed.has(message.id));
+  const messages = spoken.filter((message) => !removed.has(message.id));
   const decisions = options.messages.map((message) => {
+    if (message.status === "superseded") {
+      return {
+        messageId: message.id,
+        action: "removed",
+        reason: "superseded",
+        tokens: { provenance: "unavailable" }
+      };
+    }
     const turnIndex = turns.findIndex((turn2) => turn2.messages.some((item) => item.id === message.id));
     const turn = turns[turnIndex];
     let reason = "within-budget";
@@ -975,21 +1059,14 @@ function createRuntimeAdmissionLanes() {
 }
 
 // src/agent-runtime/run-execution.ts
-import { stepCountIs, streamText } from "ai";
+import {
+  stepCountIs,
+  streamText
+} from "ai";
 
 // src/agent-runtime/runtime-internals.ts
 import { z as z5 } from "zod";
 
-// src/agent-runtime/terminal-status.ts
-function assistantStatus(reason) {
-  if (reason === "success" || reason === "policy_stop")
-    return "completed";
-  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
-    return "interrupted";
-  }
-  return "failed";
-}
-
 // src/agent-runtime/terminal-commit.ts
 class AgentRuntimeConflictError extends Error {
   constructor(operation) {
@@ -1016,10 +1093,12 @@ function canonicalTerminal(snapshot, runId, retainedAssistant) {
     assistant,
     reason: run.terminalReason,
     committedByCaller: false,
-    ...run.terminalPolicyName && { policyName: run.terminalPolicyName }
+    ...run.terminalPolicyName && { policyName: run.terminalPolicyName },
+    ...run.usage && { usage: run.usage }
   };
 }
 function interruptedCandidate(candidate, run, now) {
+  const reason = candidate.reason === "superseded" ? "superseded" : "interrupted";
   const hasInterruptControl = candidate.assistant.parts.some((part) => part.type === "control" && part.reason === "run-interrupted");
   const parts = hasInterruptControl ? candidate.assistant.parts : [
     ...candidate.assistant.parts,
@@ -1029,11 +1108,11 @@ function interruptedCandidate(candidate, run, now) {
     run,
     assistant: AgentMessageSchema.parse({
       ...candidate.assistant,
-      status: "interrupted",
+      status: assistantStatus(reason),
       parts,
       updatedAt: now().toISOString()
     }),
-    reason: "interrupted"
+    reason
   };
 }
 function canRetryTerminal(current, previous, runtimeEpoch) {
@@ -1052,7 +1131,8 @@ async function commitAgentRunTerminal(input) {
       },
       assistant: candidate.assistant,
       reason: candidate.reason,
-      ...candidate.policyName && { policyName: candidate.policyName }
+      ...candidate.policyName && { policyName: candidate.policyName },
+      ...candidate.usage && { usage: candidate.usage }
     });
     if (committed.outcome === "applied") {
       const terminal2 = canonicalTerminal(committed.snapshot, candidate.run.id);
@@ -1112,8 +1192,80 @@ function abortTerminalReason(signal) {
     return "shutdown";
   if (signal.reason === "timeout")
     return "timeout";
+  if (signal.reason === "supersede")
+    return "superseded";
   return "interrupted";
 }
+function addUsage(total, step) {
+  const sum = (left, right) => {
+    if (left?.value === undefined && right?.value === undefined) {
+      return { provenance: "unavailable" };
+    }
+    if (left?.value === undefined)
+      return { ...right, provenance: "computed" };
+    if (right?.value === undefined)
+      return { ...left, provenance: "computed" };
+    return { value: left.value + right.value, provenance: "computed" };
+  };
+  const sumCost = (left, right) => {
+    if (left?.value === undefined || right?.value === undefined) {
+      return { provenance: "unavailable" };
+    }
+    if (left.currency !== right.currency)
+      return { provenance: "unavailable" };
+    return {
+      value: left.value + right.value,
+      ...left.currency && { currency: left.currency },
+      provenance: "computed"
+    };
+  };
+  if (!total)
+    return step;
+  const cost = sumCost(total.cost, step.cost);
+  return {
+    inputTokens: sum(total.inputTokens, step.inputTokens),
+    outputTokens: sum(total.outputTokens, step.outputTokens),
+    reasoningTokens: sum(total.reasoningTokens, step.reasoningTokens),
+    cacheReadTokens: sum(total.cacheReadTokens, step.cacheReadTokens),
+    cacheWriteTokens: sum(total.cacheWriteTokens, step.cacheWriteTokens),
+    ...cost && { cost }
+  };
+}
+function mergeRunTotals(sdkTotal, accumulated) {
+  const pick = (total, ours) => total?.value !== undefined ? { value: total.value, provenance: "computed" } : ours ?? { provenance: "unavailable" };
+  return {
+    inputTokens: pick(sdkTotal.inputTokens, accumulated?.inputTokens),
+    outputTokens: pick(sdkTotal.outputTokens, accumulated?.outputTokens),
+    reasoningTokens: pick(sdkTotal.reasoningTokens, accumulated?.reasoningTokens),
+    cacheReadTokens: pick(sdkTotal.cacheReadTokens, accumulated?.cacheReadTokens),
+    cacheWriteTokens: pick(sdkTotal.cacheWriteTokens, accumulated?.cacheWriteTokens),
+    cost: accumulated?.cost ?? { provenance: "unavailable" }
+  };
+}
+function statedUsage(usage) {
+  const stated = (value) => value ?? { provenance: "unavailable" };
+  if (!usage)
+    return unknownUsage();
+  return {
+    inputTokens: stated(usage.inputTokens),
+    outputTokens: stated(usage.outputTokens),
+    reasoningTokens: stated(usage.reasoningTokens),
+    cacheReadTokens: stated(usage.cacheReadTokens),
+    cacheWriteTokens: stated(usage.cacheWriteTokens),
+    cost: stated(usage.cost)
+  };
+}
+function unknownUsage() {
+  const nothing = { provenance: "unavailable" };
+  return {
+    inputTokens: nothing,
+    outputTokens: nothing,
+    reasoningTokens: nothing,
+    cacheReadTokens: nothing,
+    cacheWriteTokens: nothing,
+    cost: nothing
+  };
+}
 function normalizeSdkUsage(value) {
   const reported = (tokens) => tokens === undefined ? { provenance: "unavailable" } : { value: tokens, provenance: "provider-reported" };
   return {
@@ -1219,7 +1371,8 @@ function createRunExecutor(dependencies) {
     let eventCount = 0;
     let sequence = 0;
     let terminalReason = "success";
-    let usage;
+    let usage = input.acceptedRun.usage;
+    let sawProviderFinish = false;
     let step = 0;
     let selectedModel;
     let internalCause;
@@ -1261,13 +1414,14 @@ function createRunExecutor(dependencies) {
         expectedRevision: run.revision,
         ownerId: runtimeEpoch,
         ...run.fencingToken !== undefined && { fencingToken: run.fencingToken },
-        assistant
+        assistant,
+        usage: statedUsage(usage)
       }), "assistant checkpoint");
       run = findRun(snapshot.runs, run.id);
       const checkpointMetrics = {
         partial: true,
         durationMs: performance.now() - runStartedAt,
-        ...usage && { usage },
+        usage: statedUsage(usage),
         ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
       };
       await publish({
@@ -1290,6 +1444,8 @@ function createRunExecutor(dependencies) {
         });
         snapshot = compacted.snapshot;
         run = findRun(snapshot.runs, run.id);
+        if (compacted.usage)
+          usage = addUsage(usage, compacted.usage);
       }
       const assertCurrent = async () => {
         if (executionSignal.aborted)
@@ -1338,12 +1494,52 @@ function createRunExecutor(dependencies) {
       if (prompt.contextDecision === "requires-compaction") {
         throw new Error("Agent context still exceeds the model budget after compaction");
       }
-      const history = await (config.history?.project ? config.history.project(snapshot.messages) : projectAgentHistory(snapshot.messages, {
+      const projectHistory = (source) => config.history?.project ? config.history.project(source.messages) : projectAgentHistory(source.messages, {
         ...config.history?.resolveFile && { resolveFile: config.history.resolveFile },
         ...config.history?.unresolvedFile && {
           unresolvedFile: config.history.unresolvedFile
+        },
+        ...config.history?.interruptedAssistant && {
+          interruptedAssistant: config.history.interruptedAssistant
         }
-      }));
+      });
+      const history = await projectHistory(snapshot);
+      const absorbPending = async () => {
+        if (!input.absorbable?.size || executionSignal.aborted)
+          return;
+        const latest = await config.store.loadSnapshot(run.conversationId);
+        const current = latest.runs.find((candidate) => candidate.id === run.id);
+        if (current?.state !== "running" || current.ownerId !== runtimeEpoch) {
+          return;
+        }
+        const pending = latest.runs.find((candidate) => candidate.state === "queued" && input.absorbable?.has(candidate.id));
+        if (!pending)
+          return;
+        const absorbed = await config.store.absorbQueuedRun({
+          conversationId: run.conversationId,
+          runningRunId: current.id,
+          runningExpectedRevision: current.revision,
+          ownerId: runtimeEpoch,
+          ...current.fencingToken !== undefined && { fencingToken: current.fencingToken },
+          queuedRunId: pending.id,
+          queuedExpectedRevision: pending.revision
+        });
+        if (absorbed.outcome !== "applied")
+          return;
+        input.onAbsorbed?.(pending.id);
+        snapshot = absorbed.snapshot;
+        run = findRun(snapshot.runs, run.id);
+        await publish({
+          type: "run-state",
+          eventId: agentDurableEventId("run-state", run.id, snapshot.version),
+          conversationId: run.conversationId,
+          runId: run.id,
+          snapshotVersion: snapshot.version,
+          state: run.state,
+          emittedAt: now().toISOString()
+        });
+        return [...await projectHistory(snapshot)];
+      };
       const maxStepCondition = stepCountIs(maxSteps);
       const stopConditions = [
         async (options) => {
@@ -1369,8 +1565,10 @@ function createRunExecutor(dependencies) {
         abortSignal: executionSignal,
         maxRetries: 0,
         stopWhen: stopConditions,
-        ...config.loop?.prepareStep && {
-          prepareStep: (options) => config.loop?.prepareStep?.({ ...options, ...runtimeContext })
+        prepareStep: async (options) => {
+          const absorbed = await absorbPending();
+          const prepared = await config.loop?.prepareStep?.({ ...options, ...runtimeContext }) ?? {};
+          return absorbed && !prepared.messages ? { ...prepared, messages: absorbed } : prepared;
         }
       });
       for await (const part of result.stream) {
@@ -1585,7 +1783,7 @@ function createRunExecutor(dependencies) {
             usage: part.usage,
             providerMetadata: part.providerMetadata
           }) ?? normalizeSdkUsage(part.usage);
-          usage = stepUsage;
+          usage = addUsage(usage, stepUsage);
           config.observe?.emit({
             schemaVersion: 1,
             eventId: generateId(),
@@ -1603,11 +1801,14 @@ function createRunExecutor(dependencies) {
           });
           step += 1;
         } else if (part.type === "finish" && part.finishReason !== "stop") {
-          terminalReason = "policy_stop";
+          if (terminalReason === "success") {
+            terminalReason = part.finishReason === "error" ? "provider_failure" : "provider_stop";
+            internalCause ??= { finishReason: part.finishReason };
+          }
         }
         if (part.type === "finish") {
-          const aggregate = normalizeSdkUsage(part.totalUsage);
-          usage = { ...aggregate, ...usage?.cost && { cost: usage.cost } };
+          sawProviderFinish = true;
+          usage = mergeRunTotals(normalizeSdkUsage(part.totalUsage), usage);
         }
         if (eventCount % checkpointEveryEvents === 0)
           await checkpoint();
@@ -1643,47 +1844,67 @@ function createRunExecutor(dependencies) {
       parts,
       updatedAt: now().toISOString()
     });
-    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 }
-    } : undefined;
-    if (terminalMetrics) {
+    const spent = statedUsage(usage);
+    const emitSpend = (report) => {
       config.observe?.emit({
         schemaVersion: 1,
-        eventId: agentDurableEventId("terminal", run.id, snapshot.version),
+        eventId: report.eventId,
         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,
+        state: report.state,
+        terminalReason: report.reason,
         ...selectedModel && { modelId: selectedModel.descriptor.modelId },
-        durationMs: terminalMetrics.durationMs,
-        ...usage && { usage },
+        durationMs: performance.now() - runStartedAt,
+        usage: spent,
         ...internalCause !== undefined && { internalCause },
         ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt },
         emittedAt: now().toISOString()
       });
+    };
+    const unsettledEventId = (version) => agentDurableEventId("terminal", `${run.id}:${runtimeEpoch}`, version);
+    let terminal;
+    try {
+      terminal = await commitAgentRunTerminal({
+        store: config.store,
+        runtimeEpoch,
+        candidate: {
+          run,
+          assistant,
+          reason: terminalReason,
+          ...terminalPolicyName && { policyName: terminalPolicyName },
+          usage: spent
+        },
+        now
+      });
+    } catch (error) {
+      emitSpend({
+        eventId: unsettledEventId(snapshot.version),
+        state: run.state,
+        reason: terminalReason
+      });
+      throw error;
+    }
+    snapshot = terminal.snapshot;
+    run = terminal.run;
+    assistant = terminal.assistant;
+    terminalReason = terminal.reason;
+    terminalPolicyName = terminal.policyName;
+    const terminalMetrics = terminal.committedByCaller ? {
+      partial: !sawProviderFinish,
+      durationMs: performance.now() - runStartedAt,
+      usage: spent,
+      ...firstOutputAt !== undefined && { ttftMs: firstOutputAt - runStartedAt }
+    } : undefined;
+    emitSpend({
+      eventId: terminal.committedByCaller ? agentDurableEventId("terminal", run.id, snapshot.version) : unsettledEventId(snapshot.version),
+      state: run.state,
+      reason: terminalReason
+    });
+    if (terminalMetrics) {
       await publish({
         type: "terminal",
         eventId: agentDurableEventId("terminal", run.id, snapshot.version),
@@ -1731,6 +1952,9 @@ function createAgentRuntime(config) {
   if (idleTimeoutMs !== undefined && (!Number.isSafeInteger(idleTimeoutMs) || idleTimeoutMs < 1)) {
     throw new TypeError("idleTimeoutMs must be a positive safe integer");
   }
+  const absorbable = new Set;
+  const absorbedInto = new Map;
+  const runResults = new Map;
   const policyNames = new Set(["max-steps"]);
   for (const policy of config.loop?.stopPolicies ?? []) {
     if (!policy.name || policyNames.has(policy.name)) {
@@ -1863,7 +2087,8 @@ function createAgentRuntime(config) {
       if (existingTicket)
         return existingTicket;
       const key = config.runs?.key?.(input) ?? input.conversationId;
-      const policy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
+      const declaredPolicy = typeof config.runs?.inputPolicy === "function" ? config.runs.inputPolicy(input) : config.runs?.inputPolicy ?? "queue";
+      const policy = declaredPolicy === "inject" ? "queue" : declaredPolicy;
       const nowIso = now().toISOString();
       const inputMessageId = rawInput.recordIds?.inputMessageId ?? generateId();
       const runId = rawInput.recordIds?.runId ?? generateId();
@@ -1989,6 +2214,8 @@ function createAgentRuntime(config) {
             state: acceptedRun.state,
             emittedAt: now().toISOString()
           });
+          if (declaredPolicy === "inject")
+            absorbable.add(acceptedRun.id);
           outerAccepted.resolve();
           if (acceptance.outcome === "duplicate") {
             if (!acceptedRun.terminalReason) {
@@ -2037,7 +2264,25 @@ function createAgentRuntime(config) {
                 await waitForAdmissionAcceptances(reservation.lane);
               return {
                 runId: acceptedRun.id,
-                execute: () => executeRun({ acceptedRun, context, signal })
+                execute: () => {
+                  const answeredBy = absorbedInto.get(acceptedRun.id);
+                  const answer = answeredBy ? runResults.get(answeredBy) : undefined;
+                  if (answer)
+                    return answer;
+                  const running = executeRun({
+                    acceptedRun,
+                    context,
+                    signal,
+                    absorbable,
+                    onAbsorbed: (absorbedRunId) => {
+                      absorbedInto.set(absorbedRunId, acceptedRun.id);
+                    }
+                  });
+                  runResults.set(acceptedRun.id, running);
+                  return running.finally(() => {
+                    absorbable.delete(acceptedRun.id);
+                  });
+                }
               };
             }
           });
@@ -2270,7 +2515,8 @@ var CheckpointRunAssistantSchema = z6.object({
   expectedRevision: AgentRecordVersionSchema,
   ownerId: z6.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
-  assistant: AgentMessageSchema
+  assistant: AgentMessageSchema,
+  usage: AgentUsageSchema.optional()
 });
 var CommitRunTerminalSchema = z6.object({
   conversationId: AgentRecordIdSchema,
@@ -2280,7 +2526,17 @@ var CommitRunTerminalSchema = z6.object({
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z6.string().min(1).optional()
+  policyName: z6.string().min(1).optional(),
+  usage: AgentUsageSchema.optional()
+});
+var AbsorbQueuedRunSchema = z6.object({
+  conversationId: AgentRecordIdSchema,
+  runningRunId: AgentRecordIdSchema,
+  runningExpectedRevision: AgentRecordVersionSchema,
+  ownerId: z6.string().min(1),
+  fencingToken: AgentRecordVersionSchema.optional(),
+  queuedRunId: AgentRecordIdSchema,
+  queuedExpectedRevision: AgentRecordVersionSchema
 });
 var RequestRunInterruptSchema = z6.object({
   conversationId: AgentRecordIdSchema,
@@ -2426,10 +2682,13 @@ function conflict(actualVersion) {
   return { outcome: "conflict", actualVersion };
 }
 function terminalState(reason) {
-  if (reason === "success" || reason === "policy_stop")
+  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
     return "completed";
+  }
   if (reason === "interrupted")
     return "interrupted";
+  if (reason === "superseded")
+    return "superseded";
   if (reason === "cancelled" || reason === "shutdown" || reason === "timeout") {
     return "cancelled";
   }
@@ -2447,6 +2706,7 @@ function applied(current, input, effects) {
       messages: input.messages ?? current.messages
     }),
     ...effects?.runRecord && { runRecord: effects.runRecord },
+    ...effects?.secondaryRunRecord && { secondaryRunRecord: effects.secondaryRunRecord },
     ...effects?.admissionReceipt && { admissionReceipt: effects.admissionReceipt },
     ...effects?.historyMutation && { historyMutation: effects.historyMutation }
   };
@@ -2490,6 +2750,39 @@ function reduceStore(current, operation) {
       historyMutation: { type: "admit", input: input.input }
     });
   }
+  if (operation.type === "absorb") {
+    const input = operation.input;
+    if (current.conversationId !== input.conversationId)
+      return { outcome: "not_found" };
+    const running = current.runs.find((candidate) => candidate.id === input.runningRunId);
+    const queued = current.runs.find((candidate) => candidate.id === input.queuedRunId);
+    if (!running || !queued)
+      return { outcome: "not_found" };
+    if (running.revision !== input.runningExpectedRevision || running.state !== "running" || running.ownerId !== input.ownerId || input.fencingToken !== undefined && running.fencingToken !== input.fencingToken) {
+      return conflict(running.revision);
+    }
+    if (queued.revision !== input.queuedExpectedRevision || queued.state !== "queued" || queued.ownerId !== undefined || queued.terminalReason !== undefined || queued.id === running.id) {
+      return conflict(queued.revision);
+    }
+    const stamp = new Date().toISOString();
+    const grown = AgentRunSchema.parse({
+      ...running,
+      inputMessageIds: [...running.inputMessageIds, ...queued.inputMessageIds],
+      revision: running.revision + 1,
+      updatedAt: stamp
+    });
+    const emptied = AgentRunSchema.parse({
+      ...queued,
+      state: "absorbed",
+      absorbedIntoRunId: running.id,
+      revision: queued.revision + 1,
+      updatedAt: stamp
+    });
+    return applied(current, { runs: replaceRun(replaceRun(current.runs, grown), emptied) }, {
+      runRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: grown }),
+      secondaryRunRecord: AgentStoredRunSchema.parse({ schemaVersion: 1, run: emptied })
+    });
+  }
   const conversationId = operation.input.conversationId;
   const run = operation.type === "compact" ? undefined : current.runs.find((candidate) => candidate.id === operation.input.runId);
   if (operation.type !== "compact" && !run)
@@ -2519,6 +2812,7 @@ function reduceStore(current, operation) {
     }
     const next = AgentRunSchema.parse({
       ...run,
+      ...input.usage && { usage: input.usage },
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
@@ -2605,6 +2899,7 @@ function reduceStore(current, operation) {
       state: terminalState(input.reason),
       terminalReason: input.reason,
       ...input.policyName && { terminalPolicyName: input.policyName },
+      ...input.usage && { usage: input.usage },
       revision: run.revision + 1,
       updatedAt: new Date().toISOString()
     });
@@ -2693,7 +2988,7 @@ function createAgentRuntimeStore(driver) {
   });
   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;
+    const operationRunId = operation.type === "accept" ? operation.input.coalesceIntoRunId : operation.type === "compact" ? undefined : operation.type === "absorb" ? operation.input.queuedRunId : operation.input.runId;
     const [stored, messages, activeRecords, operationRecord, duplicateReceipt] = await Promise.all([
       driver.head.load(transaction, conversationId),
       driver.history.load(transaction, conversationId),
@@ -2774,6 +3069,9 @@ function createAgentRuntimeStore(driver) {
       return conflict(outcome.actualVersion);
     if (reduced.runRecord)
       await driver.runs.save(transaction, reduced.runRecord);
+    if (reduced.secondaryRunRecord) {
+      await driver.runs.save(transaction, reduced.secondaryRunRecord);
+    }
     if (reduced.admissionReceipt) {
       await driver.admissions.create(transaction, reduced.admissionReceipt);
     }
@@ -2797,6 +3095,7 @@ function createAgentRuntimeStore(driver) {
       type: "interrupt",
       input: RequestRunInterruptSchema.parse(input)
     }),
+    absorbQueuedRun: (input) => mutate({ type: "absorb", input: AbsorbQueuedRunSchema.parse(input) }),
     recoverRun: (input) => mutate({ type: "recover", input: RecoverAgentRunSchema.parse(input) }),
     commitRunTerminal: (input) => mutate({ type: "terminal", input: CommitRunTerminalSchema.parse(input) }),
     replaceCompactedRange: (input) => mutate({
@@ -2969,6 +3268,7 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 export {
+  AbsorbQueuedRunSchema,
   AcceptInputAndAssignRunSchema,
   AcquireAgentRunSchema,
   AgentAdmissionEventSchema,