stitchkit 0.94.0 → 0.94.1

package/dist/entrypoints/agent-runtime/testing.js

@@ -1,10 +1,10 @@
 import {
   createMemoryAgentRuntimeStore
-} from "../../index-xsqjkha9.js";
-import"../../index-58k4fp34.js";
+} from "../../index-sp1tzwnb.js";
+import"../../index-wsm5w4ee.js";
 import {
   decodeAgentConversationArchive
-} from "../../index-1nd48tm9.js";
+} from "../../index-gxrt5h6v.js";
 import {
   AgentMessageSchema,
   AgentRunSchema
@@ -153,7 +153,7 @@ function createReplayAgentProvider(input) {
     calls: (modelId) => calls.get(modelId) ?? 0
   };
 }
-// src/agent-runtime/store-conformance.ts
+// src/agent-runtime/store-conformance-support.ts
 function userMessage(conversationId, id) {
   return AgentMessageSchema.parse({
     schemaVersion: 1,
@@ -184,90 +184,9 @@ function requireOutcome(actual, expected) {
     throw new Error(`Agent store conformance expected ${expected}, received ${actual.outcome}`);
   }
 }
-async function runAgentStoreConformance(config) {
-  const run = `conformance-${crypto.randomUUID()}`;
-  const context = {
-    conversationIds: [
-      run,
-      `${run}-recovery`,
-      `${run}-absorb`,
-      `${run}-causal-history`,
-      `${run}-causal-active`,
-      `${run}-interrupt-priority`,
-      `${run}-ledger`,
-      `${run}-archive`,
-      `${run}-seed`
-    ]
-  };
-  const store = await config.createStore(context);
-  let failure;
-  try {
-    await conformanceScenario(store, context.conversationIds);
-  } catch (error) {
-    failure = error;
-  }
-  try {
-    await config.cleanup?.(context);
-  } catch (cleanupError) {
-    if (failure === undefined)
-      throw cleanupError;
-    throw new AggregateError([failure, cleanupError], `${failure instanceof Error ? failure.message : String(failure)} (cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)})`);
-  }
-  if (failure !== undefined)
-    throw failure;
-}
-async function seedScenario(store, conversationId) {
-  const input = {
-    conversationId,
-    seedKey: "brief",
-    inputs: [userMessage(conversationId, "seed-a"), userMessage(conversationId, "seed-b")]
-  };
-  const first = await store.seedConversationInput(input);
-  requireOutcome(first, "applied");
-  const before = await store.loadSnapshot(conversationId);
-  if (before.messages.map((message) => message.id).join(",") !== "seed-a,seed-b")
-    throw new Error("Seed conformance: complete ordered seed missing");
-  await Promise.all([store.seedConversationInput(input), store.seedConversationInput(input)]);
-  const repeated = await store.loadSnapshot(conversationId);
-  if (repeated.version !== before.version || repeated.messages.length !== 2)
-    throw new Error("Seed conformance: replay changed history");
-  const compacted = await store.replaceCompactedRange({
-    conversationId,
-    expectedVersion: repeated.version,
-    replacedMessageIds: ["seed-a", "seed-b"],
-    summary: AgentMessageSchema.parse({
-      ...userMessage(conversationId, "seed-summary"),
-      role: "summary"
-    })
-  });
-  requireOutcome(compacted, "applied");
-  await store.seedConversationInput(input);
-  const after = await store.loadSnapshot(conversationId);
-  if (after.messages.some((message) => message.id === "seed-a" || message.id === "seed-b"))
-    throw new Error("Seed conformance: compacted instructions resurrected");
-}
-async function conformanceScenario(store, conversationIds) {
-  const [
-    conversationId,
-    recoveryConversationId,
-    absorbConversationId,
-    causalHistoryConversationId,
-    causalActiveConversationId,
-    interruptPriorityConversationId,
-    ledgerConversationId,
-    archiveConversationId,
-    seedConversationId
-  ] = conversationIds;
-  if (seedConversationId)
-    await seedScenario(store, seedConversationId);
-  if (ledgerConversationId)
-    await ledgerScenario(store, ledgerConversationId);
-  if (archiveConversationId)
-    await archiveScenario(store, archiveConversationId);
-  if (!conversationId || !recoveryConversationId || !absorbConversationId || !causalHistoryConversationId || !causalActiveConversationId || !interruptPriorityConversationId) {
-    throw new Error("Agent store conformance requires six conversation identities");
-  }
-  const absentConversationId = `${conversationId}-absent`;
+
+// src/agent-runtime/store-conformance-lifecycle.ts
+async function admissionPhase(store, conversationId) {
   const firstInput = userMessage(conversationId, "input-1");
   const firstRun = queuedRun(conversationId, firstInput.id, "run-1");
   const accepted = await store.acceptInputAndAssignRun({
@@ -354,6 +273,9 @@ async function conformanceScenario(store, conversationIds) {
   if (duplicateAfterCompaction.input.id !== firstInput.id) {
     throw new Error("Compaction discarded the canonical duplicate admission input");
   }
+  return assigned;
+}
+async function fencingPhase(store, conversationId, assigned) {
   const acquired = await store.acquireRun({
     conversationId,
     runId: assigned.id,
@@ -477,6 +399,10 @@ async function conformanceScenario(store, conversationIds) {
   if (foreignOwner.outcome !== "conflict") {
     throw new Error("A checkpoint from another owner must conflict");
   }
+  return { running, checkpoint, checkpointedRun, terminalAssistant };
+}
+async function boundedReadsPhase(store, conversationId, absentConversationId, checkpointed) {
+  const { running, checkpoint, checkpointedRun } = checkpointed;
   const liveView = await store.loadRun({ conversationId, runId: running.id });
   if (!liveView)
     throw new Error("loadRun must find a run of this conversation");
@@ -521,6 +447,9 @@ async function conformanceScenario(store, conversationIds) {
   if ((await store.listActiveRuns(absentConversationId)).length !== 0) {
     throw new Error("listActiveRuns must be empty for an unknown conversation");
   }
+}
+async function interruptPhase(store, conversationId, checkpointed) {
+  const { running, checkpointedRun } = checkpointed;
   const recoverable = await store.scanRecoverable({ limit: 10 });
   if (!recoverable.items.some((item) => item.run.id === running.id)) {
     throw new Error("A running run must appear in a recoverable scan");
@@ -562,133 +491,10 @@ async function conformanceScenario(store, conversationIds) {
   if (interruptedRun.usage?.cost?.value !== 0.25) {
     throw new Error("An interrupt must not discard the figure the run had already spent");
   }
-  const terminalUsage = {
-    inputTokens: { value: 3000, provenance: "computed" },
-    outputTokens: { value: 300, provenance: "computed" },
-    reasoningTokens: { value: 30, provenance: "computed" },
-    cacheReadTokens: { value: 200, provenance: "computed" },
-    cacheWriteTokens: { value: 100, provenance: "computed" },
-    cost: { value: 1.5, currency: "USD", provenance: "computed" }
-  };
-  const terminalResults = await Promise.all([
-    store.commitRunTerminal({
-      conversationId,
-      runId: running.id,
-      expectedRevision: interruptedRun.revision,
-      ownerId: "conformance-owner",
-      assistant: terminalAssistant,
-      reason: "success",
-      usage: terminalUsage
-    }),
-    store.commitRunTerminal({
-      conversationId,
-      runId: running.id,
-      expectedRevision: interruptedRun.revision,
-      ownerId: "conformance-owner",
-      assistant: terminalAssistant,
-      reason: "success",
-      usage: terminalUsage
-    })
-  ]);
-  const terminalOutcomes = terminalResults.map((result) => result.outcome).sort();
-  if (terminalOutcomes.join(",") !== "applied,conflict") {
-    throw new Error(`Terminal race was not linearized: ${terminalOutcomes.join(",")}`);
-  }
-  const terminalApplied = terminalResults.find((result) => result.outcome === "applied");
-  if (terminalApplied?.outcome !== "applied") {
-    throw new Error("Terminal race produced no applied result");
-  }
-  const settledRun = terminalApplied.snapshot.runs.find((run) => run.id === running.id);
-  if (JSON.stringify(settledRun?.usage) !== JSON.stringify(terminalUsage)) {
-    throw new Error("Terminal commit did not persist the run usage it was given");
-  }
-  const terminalView = await store.loadRun({ conversationId, runId: running.id });
-  if (terminalView?.run.terminalReason !== "success") {
-    throw new Error("loadRun must report the terminal reason a settled run ended with");
-  }
-  if (JSON.stringify(terminalView.run.usage) !== JSON.stringify(terminalUsage)) {
-    throw new Error("loadRun must return every persisted terminal usage field");
-  }
-  if (JSON.stringify(terminalView.assistant) !== JSON.stringify(terminalAssistant)) {
-    throw new Error("loadRun must retain the answer a settled run produced");
-  }
-  if ((await store.listActiveRuns(conversationId)).some((run) => run.id === running.id)) {
-    throw new Error("listActiveRuns must drop a run once it has ended");
-  }
-  const compactedTerminal = await store.replaceCompactedRange({
-    conversationId,
-    expectedVersion: terminalApplied.snapshot.version,
-    replacedMessageIds: ["summary-1", terminalAssistant.id],
-    summary: AgentMessageSchema.parse({
-      schemaVersion: 1,
-      id: "summary-2",
-      conversationId,
-      role: "summary",
-      status: "committed",
-      parts: [{ type: "text", text: "terminal history" }],
-      createdAt: "2026-08-22T00:00:03.000Z",
-      updatedAt: "2026-08-22T00:00:03.000Z"
-    })
-  });
-  requireOutcome(compactedTerminal, "applied");
-  const duplicateTerminal = await store.acceptInputAndAssignRun({
-    idempotencyKey: "request-1",
-    input: userMessage(conversationId, "discarded-terminal-input"),
-    run: queuedRun(conversationId, "discarded-terminal-input", "discarded-terminal-run")
-  });
-  requireOutcome(duplicateTerminal, "duplicate");
-  if (duplicateTerminal.run.terminalReason !== "success" || JSON.stringify(duplicateTerminal.assistant) !== JSON.stringify(terminalAssistant)) {
-    throw new Error("Compaction discarded the canonical duplicate terminal result");
-  }
-  const recoveryInput = userMessage(recoveryConversationId, "recovery-input");
-  const recoveryRun = queuedRun(recoveryConversationId, recoveryInput.id, "recovery-run");
-  const recoveryAccepted = await store.acceptInputAndAssignRun({
-    idempotencyKey: "recovery-request",
-    input: recoveryInput,
-    run: recoveryRun
-  });
-  requireOutcome(recoveryAccepted, "applied");
-  const recoveryAssigned = recoveryAccepted.snapshot.runs.find((run) => run.id === recoveryRun.id);
-  if (!recoveryAssigned)
-    throw new Error("Recovery run disappeared after admission");
-  const recoveryAcquired = await store.acquireRun({
-    conversationId: recoveryConversationId,
-    runId: recoveryAssigned.id,
-    expectedRevision: recoveryAssigned.revision,
-    ownerId: "abandoned-owner"
-  });
-  requireOutcome(recoveryAcquired, "applied");
-  const abandonedRun = recoveryAcquired.snapshot.runs.find((run) => run.id === recoveryRun.id);
-  if (!abandonedRun)
-    throw new Error("Recovery run disappeared after acquisition");
-  const abandoned = await store.recoverRun({
-    conversationId: recoveryConversationId,
-    runId: abandonedRun.id,
-    expectedRevision: abandonedRun.revision,
-    action: "abandon"
-  });
-  requireOutcome(abandoned, "applied");
-  const terminalRun = abandoned.snapshot.runs.find((run) => run.id === abandonedRun.id);
-  const terminalMessage = abandoned.snapshot.messages.find((message) => message.id === abandonedRun.assistantMessageId);
-  if (terminalRun?.state !== "abandoned" || terminalMessage?.status !== "failed") {
-    throw new Error("Abandon recovery did not atomically terminalize its assistant record");
-  }
-  const abandonedView = await store.loadRun({
-    conversationId: recoveryConversationId,
-    runId: abandonedRun.id
-  });
-  if (abandonedView?.run.state !== "abandoned" || abandonedView.run.terminalReason !== "abandoned" || abandonedView.assistant?.status !== "failed") {
-    throw new Error("The canonical run record disagrees with its abandoned index projection");
-  }
-  const afterAbandon = await store.scanRecoverable({ limit: 100 });
-  if (afterAbandon.items.some((item) => item.run.id === abandonedRun.id)) {
-    throw new Error("The recoverable index still exposes a canonically abandoned run");
-  }
-  await assertCausalHistoryOrder(store, causalHistoryConversationId);
-  await assertActiveRunCausalOrder(store, causalActiveConversationId);
-  await assertInterruptPriorityOrder(store, interruptPriorityConversationId);
-  await assertAbsorptionIsAtomic(store, absorbConversationId);
+  return interruptedRun;
 }
+
+// src/agent-runtime/store-conformance-ordering.ts
 async function assertInterruptPriorityOrder(store, conversationId) {
   const inputs = ["priority-a", "priority-b", "priority-c"].map((id) => userMessage(conversationId, id));
   const [inputA, inputB, inputC] = inputs;
@@ -931,6 +737,232 @@ async function assertAbsorptionIsAtomic(store, conversationId) {
     throw new Error("A retried absorbed key must still name its own input");
   }
 }
+
+// src/agent-runtime/store-conformance-terminal.ts
+async function terminalPhase(store, conversationId, checkpointed, interruptedRun) {
+  const { running, terminalAssistant } = checkpointed;
+  const terminalUsage = {
+    inputTokens: { value: 3000, provenance: "computed" },
+    outputTokens: { value: 300, provenance: "computed" },
+    reasoningTokens: { value: 30, provenance: "computed" },
+    cacheReadTokens: { value: 200, provenance: "computed" },
+    cacheWriteTokens: { value: 100, provenance: "computed" },
+    cost: { value: 1.5, currency: "USD", provenance: "computed" }
+  };
+  const terminalResults = await Promise.all([
+    store.commitRunTerminal({
+      conversationId,
+      runId: running.id,
+      expectedRevision: interruptedRun.revision,
+      ownerId: "conformance-owner",
+      assistant: terminalAssistant,
+      reason: "success",
+      usage: terminalUsage
+    }),
+    store.commitRunTerminal({
+      conversationId,
+      runId: running.id,
+      expectedRevision: interruptedRun.revision,
+      ownerId: "conformance-owner",
+      assistant: terminalAssistant,
+      reason: "success",
+      usage: terminalUsage
+    })
+  ]);
+  const terminalOutcomes = terminalResults.map((result) => result.outcome).sort();
+  if (terminalOutcomes.join(",") !== "applied,conflict") {
+    throw new Error(`Terminal race was not linearized: ${terminalOutcomes.join(",")}`);
+  }
+  const terminalApplied = terminalResults.find((result) => result.outcome === "applied");
+  if (terminalApplied?.outcome !== "applied") {
+    throw new Error("Terminal race produced no applied result");
+  }
+  const settledRun = terminalApplied.snapshot.runs.find((run) => run.id === running.id);
+  if (JSON.stringify(settledRun?.usage) !== JSON.stringify(terminalUsage)) {
+    throw new Error("Terminal commit did not persist the run usage it was given");
+  }
+  const terminalView = await store.loadRun({ conversationId, runId: running.id });
+  if (terminalView?.run.terminalReason !== "success") {
+    throw new Error("loadRun must report the terminal reason a settled run ended with");
+  }
+  if (JSON.stringify(terminalView.run.usage) !== JSON.stringify(terminalUsage)) {
+    throw new Error("loadRun must return every persisted terminal usage field");
+  }
+  if (JSON.stringify(terminalView.assistant) !== JSON.stringify(terminalAssistant)) {
+    throw new Error("loadRun must retain the answer a settled run produced");
+  }
+  if ((await store.listActiveRuns(conversationId)).some((run) => run.id === running.id)) {
+    throw new Error("listActiveRuns must drop a run once it has ended");
+  }
+  const compactedTerminal = await store.replaceCompactedRange({
+    conversationId,
+    expectedVersion: terminalApplied.snapshot.version,
+    replacedMessageIds: ["summary-1", terminalAssistant.id],
+    summary: AgentMessageSchema.parse({
+      schemaVersion: 1,
+      id: "summary-2",
+      conversationId,
+      role: "summary",
+      status: "committed",
+      parts: [{ type: "text", text: "terminal history" }],
+      createdAt: "2026-08-22T00:00:03.000Z",
+      updatedAt: "2026-08-22T00:00:03.000Z"
+    })
+  });
+  requireOutcome(compactedTerminal, "applied");
+  const duplicateTerminal = await store.acceptInputAndAssignRun({
+    idempotencyKey: "request-1",
+    input: userMessage(conversationId, "discarded-terminal-input"),
+    run: queuedRun(conversationId, "discarded-terminal-input", "discarded-terminal-run")
+  });
+  requireOutcome(duplicateTerminal, "duplicate");
+  if (duplicateTerminal.run.terminalReason !== "success" || JSON.stringify(duplicateTerminal.assistant) !== JSON.stringify(terminalAssistant)) {
+    throw new Error("Compaction discarded the canonical duplicate terminal result");
+  }
+}
+async function abandonPhase(store, recoveryConversationId) {
+  const recoveryInput = userMessage(recoveryConversationId, "recovery-input");
+  const recoveryRun = queuedRun(recoveryConversationId, recoveryInput.id, "recovery-run");
+  const recoveryAccepted = await store.acceptInputAndAssignRun({
+    idempotencyKey: "recovery-request",
+    input: recoveryInput,
+    run: recoveryRun
+  });
+  requireOutcome(recoveryAccepted, "applied");
+  const recoveryAssigned = recoveryAccepted.snapshot.runs.find((run) => run.id === recoveryRun.id);
+  if (!recoveryAssigned)
+    throw new Error("Recovery run disappeared after admission");
+  const recoveryAcquired = await store.acquireRun({
+    conversationId: recoveryConversationId,
+    runId: recoveryAssigned.id,
+    expectedRevision: recoveryAssigned.revision,
+    ownerId: "abandoned-owner"
+  });
+  requireOutcome(recoveryAcquired, "applied");
+  const abandonedRun = recoveryAcquired.snapshot.runs.find((run) => run.id === recoveryRun.id);
+  if (!abandonedRun)
+    throw new Error("Recovery run disappeared after acquisition");
+  const abandoned = await store.recoverRun({
+    conversationId: recoveryConversationId,
+    runId: abandonedRun.id,
+    expectedRevision: abandonedRun.revision,
+    action: "abandon"
+  });
+  requireOutcome(abandoned, "applied");
+  const terminalRun = abandoned.snapshot.runs.find((run) => run.id === abandonedRun.id);
+  const terminalMessage = abandoned.snapshot.messages.find((message) => message.id === abandonedRun.assistantMessageId);
+  if (terminalRun?.state !== "abandoned" || terminalMessage?.status !== "failed") {
+    throw new Error("Abandon recovery did not atomically terminalize its assistant record");
+  }
+  const abandonedView = await store.loadRun({
+    conversationId: recoveryConversationId,
+    runId: abandonedRun.id
+  });
+  if (abandonedView?.run.state !== "abandoned" || abandonedView.run.terminalReason !== "abandoned" || abandonedView.assistant?.status !== "failed") {
+    throw new Error("The canonical run record disagrees with its abandoned index projection");
+  }
+  const afterAbandon = await store.scanRecoverable({ limit: 100 });
+  if (afterAbandon.items.some((item) => item.run.id === abandonedRun.id)) {
+    throw new Error("The recoverable index still exposes a canonically abandoned run");
+  }
+}
+
+// src/agent-runtime/store-conformance.ts
+async function runAgentStoreConformance(config) {
+  const run = `conformance-${crypto.randomUUID()}`;
+  const context = {
+    conversationIds: [
+      run,
+      `${run}-recovery`,
+      `${run}-absorb`,
+      `${run}-causal-history`,
+      `${run}-causal-active`,
+      `${run}-interrupt-priority`,
+      `${run}-ledger`,
+      `${run}-archive`,
+      `${run}-seed`
+    ]
+  };
+  const store = await config.createStore(context);
+  let failure;
+  try {
+    await conformanceScenario(store, context.conversationIds);
+  } catch (error) {
+    failure = error;
+  }
+  try {
+    await config.cleanup?.(context);
+  } catch (cleanupError) {
+    if (failure === undefined)
+      throw cleanupError;
+    throw new AggregateError([failure, cleanupError], `${failure instanceof Error ? failure.message : String(failure)} (cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)})`);
+  }
+  if (failure !== undefined)
+    throw failure;
+}
+async function seedScenario(store, conversationId) {
+  const input = {
+    conversationId,
+    seedKey: "brief",
+    inputs: [userMessage(conversationId, "seed-a"), userMessage(conversationId, "seed-b")]
+  };
+  const first = await store.seedConversationInput(input);
+  requireOutcome(first, "applied");
+  const before = await store.loadSnapshot(conversationId);
+  if (before.messages.map((message) => message.id).join(",") !== "seed-a,seed-b")
+    throw new Error("Seed conformance: complete ordered seed missing");
+  await Promise.all([store.seedConversationInput(input), store.seedConversationInput(input)]);
+  const repeated = await store.loadSnapshot(conversationId);
+  if (repeated.version !== before.version || repeated.messages.length !== 2)
+    throw new Error("Seed conformance: replay changed history");
+  const compacted = await store.replaceCompactedRange({
+    conversationId,
+    expectedVersion: repeated.version,
+    replacedMessageIds: ["seed-a", "seed-b"],
+    summary: AgentMessageSchema.parse({
+      ...userMessage(conversationId, "seed-summary"),
+      role: "summary"
+    })
+  });
+  requireOutcome(compacted, "applied");
+  await store.seedConversationInput(input);
+  const after = await store.loadSnapshot(conversationId);
+  if (after.messages.some((message) => message.id === "seed-a" || message.id === "seed-b"))
+    throw new Error("Seed conformance: compacted instructions resurrected");
+}
+async function conformanceScenario(store, conversationIds) {
+  const [
+    conversationId,
+    recoveryConversationId,
+    absorbConversationId,
+    causalHistoryConversationId,
+    causalActiveConversationId,
+    interruptPriorityConversationId,
+    ledgerConversationId,
+    archiveConversationId,
+    seedConversationId
+  ] = conversationIds;
+  if (seedConversationId)
+    await seedScenario(store, seedConversationId);
+  if (ledgerConversationId)
+    await ledgerScenario(store, ledgerConversationId);
+  if (archiveConversationId)
+    await archiveScenario(store, archiveConversationId);
+  if (!conversationId || !recoveryConversationId || !absorbConversationId || !causalHistoryConversationId || !causalActiveConversationId || !interruptPriorityConversationId) {
+    throw new Error("Agent store conformance requires six conversation identities");
+  }
+  const absentConversationId = `${conversationId}-absent`;
+  const assigned = await admissionPhase(store, conversationId);
+  const checkpointed = await fencingPhase(store, conversationId, assigned);
+  await boundedReadsPhase(store, conversationId, absentConversationId, checkpointed);
+  const interruptedRun = await interruptPhase(store, conversationId, checkpointed);
+  await terminalPhase(store, conversationId, checkpointed, interruptedRun);
+  await abandonPhase(store, recoveryConversationId);
+  await assertCausalHistoryOrder(store, causalHistoryConversationId);
+  await assertActiveRunCausalOrder(store, causalActiveConversationId);
+  await assertInterruptPriorityOrder(store, interruptPriorityConversationId);
+  await assertAbsorptionIsAtomic(store, absorbConversationId);
+}
 async function ledgerScenario(store, conversationId) {
   const first = await store.appendEvent({
     conversationId,