@absolutejs/voice 0.0.22-beta.255 → 0.0.22-beta.257

package/dist/index.d.ts

@@ -28,18 +28,18 @@ export type { VoiceDeliverySinkDescriptor, VoiceDeliverySinkDescriptorInput, Voi
 export type { VoiceOpsActionAuditRecord, VoiceOpsActionAuditRoutesOptions, VoiceOpsActionHistoryEntry, VoiceOpsActionHistoryReport } from './opsActionAuditRoutes';
 export type { VoiceDeliveryRuntime, VoiceDeliveryRuntimeAuditConfig, VoiceDeliveryRuntimeConfig, VoiceDeliveryRuntimeFilePresetOptions, VoiceDeliveryRuntimePresetLeaseConfig, VoiceDeliveryRuntimePresetMode, VoiceDeliveryRuntimePresetOptions, VoiceDeliveryRuntimeReport, VoiceDeliveryRuntimeRoutesOptions, VoiceDeliveryRuntimeS3PresetOptions, VoiceDeliveryRuntimeSummary, VoiceDeliveryRuntimeTickResult, VoiceDeliveryRuntimeTraceConfig, VoiceDeliveryRuntimeWebhookPresetOptions } from './deliveryRuntime';
 export { compareVoiceEvalBaseline, createVoiceFileEvalBaselineStore, createVoiceFileScenarioFixtureStore, createVoiceEvalRoutes, renderVoiceEvalBaselineHTML, renderVoiceEvalHTML, renderVoiceScenarioEvalHTML, renderVoiceScenarioFixtureEvalHTML, runVoiceScenarioEvals, runVoiceScenarioFixtureEvals, runVoiceSessionEvals } from './evalRoutes';
-export { createVoiceSimulationSuiteRoutes, renderVoiceSimulationSuiteHTML, runVoiceSimulationSuite } from './simulationSuite';
+export { assertVoiceSimulationSuiteEvidence, createVoiceSimulationSuiteRoutes, evaluateVoiceSimulationSuiteEvidence, renderVoiceSimulationSuiteHTML, runVoiceSimulationSuite } from './simulationSuite';
 export { createVoiceWorkflowContract, createVoiceWorkflowContractHandler, createVoiceWorkflowContractPreset, createVoiceWorkflowScenario, recordVoiceWorkflowContractTrace, validateVoiceWorkflowRouteResult } from './workflowContract';
 export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, createVoiceSessionReplayJSONHandler, createVoiceSessionReplayRoutes, createVoiceSessionsHTMLHandler, createVoiceSessionsJSONHandler, renderVoiceSessionsHTML, summarizeVoiceProviderFallbackRecovery, summarizeVoiceSessions, summarizeVoiceSessionReplay } from './sessionReplay';
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from './agent';
 export { assertVoiceAgentSquadContractEvidence, assertVoiceAgentSquadContract, evaluateVoiceAgentSquadContractEvidence, runVoiceAgentSquadContract } from './agentSquadContract';
 export { createVoiceToolIdempotencyKey, createVoiceToolRuntime } from './toolRuntime';
-export { createVoiceToolContract, createVoiceToolContractHTMLHandler, createVoiceToolContractJSONHandler, createVoiceToolContractRoutes, createVoiceToolRuntimeContractDefaults, renderVoiceToolContractHTML, runVoiceToolContractSuite, runVoiceToolContract } from './toolContract';
+export { assertVoiceToolContractEvidence, createVoiceToolContract, createVoiceToolContractHTMLHandler, createVoiceToolContractJSONHandler, createVoiceToolContractRoutes, createVoiceToolRuntimeContractDefaults, evaluateVoiceToolContractEvidence, renderVoiceToolContractHTML, runVoiceToolContractSuite, runVoiceToolContract } from './toolContract';
 export { createVoiceTurnLatencyHTMLHandler, createVoiceTurnLatencyJSONHandler, createVoiceTurnLatencyRoutes, renderVoiceTurnLatencyHTML, summarizeVoiceTurnLatency } from './turnLatency';
 export { createVoiceLiveLatencyRoutes, renderVoiceLiveLatencyHTML, summarizeVoiceLiveLatency } from './liveLatency';
 export { assertVoiceLatencySLOGate, buildVoiceLatencySLOGate, renderVoiceLatencySLOMarkdown } from './latencySlo';
 export { createVoiceTurnQualityHTMLHandler, createVoiceTurnQualityJSONHandler, createVoiceTurnQualityRoutes, renderVoiceTurnQualityHTML, summarizeVoiceTurnQuality } from './turnQuality';
-export { createVoiceOutcomeContractHTMLHandler, createVoiceOutcomeContractJSONHandler, createVoiceOutcomeContractRoutes, renderVoiceOutcomeContractHTML, runVoiceOutcomeContractSuite } from './outcomeContract';
+export { assertVoiceOutcomeContractEvidence, createVoiceOutcomeContractHTMLHandler, createVoiceOutcomeContractJSONHandler, createVoiceOutcomeContractRoutes, evaluateVoiceOutcomeContractEvidence, renderVoiceOutcomeContractHTML, runVoiceOutcomeContractSuite } from './outcomeContract';
 export { applyVoiceTelephonyOutcome, createMemoryVoiceTelephonyWebhookIdempotencyStore, createVoiceTelephonyOutcomePolicy, createVoiceTelephonyWebhookHandler, createVoiceTelephonyWebhookRoutes, parseVoiceTelephonyWebhookEvent, resolveVoiceTelephonyOutcome, signVoiceTwilioWebhook, verifyVoiceTwilioWebhookSignature, voiceTelephonyOutcomeToRouteResult } from './telephonyOutcome';
 export { createVoicePhoneAgent } from './phoneAgent';
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileIncidentBundleStore, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileAuditEventStore, createVoiceFileAuditSinkDeliveryStore, createVoiceFileCampaignStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
@@ -100,7 +100,7 @@ export type { VoiceAssistantHealthFailure, VoiceAssistantHealthHTMLHandlerOption
 export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssistantMemoryOptions, VoiceAssistantMemoryRecord, VoiceAssistantMemoryStore } from './assistantMemory';
 export type { VoiceDiagnosticsRoutesOptions } from './diagnosticsRoutes';
 export type { VoiceEvalBaselineComparison, VoiceEvalBaselineComparisonOptions, VoiceEvalBaselineStore, VoiceEvalBaselineSummary, VoiceEvalLink, VoiceEvalReport, VoiceEvalRoutesOptions, VoiceEvalSessionReport, VoiceEvalStatus, VoiceEvalTrendBucket, VoiceScenarioEvalDefinition, VoiceScenarioEvalReport, VoiceScenarioEvalResult, VoiceScenarioEvalSessionResult, VoiceScenarioFixture, VoiceScenarioFixtureEvalReport, VoiceScenarioFixtureEvalResult, VoiceScenarioFixtureStore } from './evalRoutes';
-export type { VoiceSimulationSuiteEvalRoutesOptions, VoiceSimulationSuiteOptions, VoiceSimulationSuiteReport, VoiceSimulationSuiteRoutesOptions, VoiceSimulationSuiteSectionSummary, VoiceSimulationSuiteStatus } from './simulationSuite';
+export type { VoiceSimulationSuiteAssertionInput, VoiceSimulationSuiteAssertionReport, VoiceSimulationSuiteEvalRoutesOptions, VoiceSimulationSuiteOptions, VoiceSimulationSuiteReport, VoiceSimulationSuiteRoutesOptions, VoiceSimulationSuiteSection, VoiceSimulationSuiteSectionSummary, VoiceSimulationSuiteStatus } from './simulationSuite';
 export type { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkflowContractField, VoiceWorkflowContractFieldMatch, VoiceWorkflowContractPresetName, VoiceWorkflowContractPresetOptions, VoiceWorkflowContractTracePayload, VoiceWorkflowContractValidation, VoiceWorkflowContractValidationIssue, VoiceWorkflowOutcome } from './workflowContract';
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceProviderFallbackRecoverySummary, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterStrategy, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
@@ -114,7 +114,7 @@ export type { VoiceTurnLatencyHTMLHandlerOptions, VoiceTurnLatencyItem, VoiceTur
 export type { VoiceLiveLatencyOptions, VoiceLiveLatencyReport, VoiceLiveLatencyRoutesOptions, VoiceLiveLatencySample, VoiceLiveLatencyStatus } from './liveLatency';
 export type { VoiceLatencySLOBudget, VoiceLatencySLOGateError, VoiceLatencySLOGateOptions, VoiceLatencySLOGateReport, VoiceLatencySLOMeasurement, VoiceLatencySLOStage, VoiceLatencySLOStageSummary, VoiceLatencySLOStatus } from './latencySlo';
 export type { VoiceTurnQualityHTMLHandlerOptions, VoiceTurnQualityItem, VoiceTurnQualityOptions, VoiceTurnQualityReport, VoiceTurnQualityRoutesOptions, VoiceTurnQualityStatus } from './turnQuality';
-export type { VoiceOutcomeContractDefinition, VoiceOutcomeContractHTMLHandlerOptions, VoiceOutcomeContractIssue, VoiceOutcomeContractOptions, VoiceOutcomeContractReport, VoiceOutcomeContractRoutesOptions, VoiceOutcomeContractStatus, VoiceOutcomeContractSuiteReport } from './outcomeContract';
+export type { VoiceOutcomeContractAssertionInput, VoiceOutcomeContractAssertionReport, VoiceOutcomeContractDefinition, VoiceOutcomeContractHTMLHandlerOptions, VoiceOutcomeContractIssue, VoiceOutcomeContractOptions, VoiceOutcomeContractReport, VoiceOutcomeContractRoutesOptions, VoiceOutcomeContractStatus, VoiceOutcomeContractSuiteReport } from './outcomeContract';
 export type { VoiceTelephonyOutcomeAction, VoiceTelephonyOutcomeDecision, VoiceTelephonyOutcomePolicy, VoiceTelephonyOutcomeProviderEvent, VoiceTelephonyOutcomeRouteResult, VoiceTelephonyOutcomeStatusDecision, VoiceTelephonyWebhookDecision, VoiceTelephonyWebhookHandlerOptions, VoiceTelephonyWebhookIdempotencyStore, VoiceTelephonyWebhookParseInput, VoiceTelephonyWebhookProvider, VoiceTelephonyWebhookRoutesOptions, VoiceTelephonyWebhookVerificationResult, StoredVoiceTelephonyWebhookDecision } from './telephonyOutcome';
 export type { VoicePhoneAgentCarrier, VoicePhoneAgentCarrierSummary, VoicePhoneAgentLifecycleStage, VoicePhoneAgentPlivoCarrier, VoicePhoneAgentRoutes, VoicePhoneAgentRoutesOptions, VoicePhoneAgentSetupReport, VoicePhoneAgentTelnyxCarrier, VoicePhoneAgentTwilioCarrier } from './phoneAgent';
 export type { VoicePhoneAgentProductionSmokeIssue, VoicePhoneAgentProductionSmokeHandlerOptions, VoicePhoneAgentProductionSmokeHTMLHandlerOptions, VoicePhoneAgentProductionSmokeOptions, VoicePhoneAgentProductionSmokeReport, VoicePhoneAgentProductionSmokeRoutesOptions, VoicePhoneAgentProductionSmokeRequirement } from './phoneAgentProductionSmoke';
@@ -133,7 +133,7 @@ export type { VoiceIOProviderRouterEvent, VoiceIOProviderRouterOptions, VoiceIOP
 export type { VoiceAgent, VoiceAgentMessage, VoiceAgentMessageRole, VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput, VoiceAgentOptions, VoiceAgentRunResult, VoiceAgentSquadContextPolicyResult, VoiceAgentSquadHandoffPolicyResult, VoiceAgentSquadHandoffStatus, VoiceAgentSquadOptions, VoiceAgentSquadState, VoiceAgentSquadStateHandoff, VoiceAgentTool, VoiceAgentToolCall, VoiceAgentToolResult } from './agent';
 export type { VoiceAgentSquadContractAssertionInput, VoiceAgentSquadContractAssertionReport, VoiceAgentSquadContractDefinition, VoiceAgentSquadContractIssue, VoiceAgentSquadContractOutcome, VoiceAgentSquadContractReport, VoiceAgentSquadContractRunOptions, VoiceAgentSquadContractTurn, VoiceAgentSquadContractTurnReport, VoiceAgentSquadHandoffExpectation, VoiceAgentSquadTurnExpectation } from './agentSquadContract';
 export type { VoiceToolRetryDelay, VoiceToolRuntime, VoiceToolRuntimeExecuteInput, VoiceToolRuntimeOptions, VoiceToolRuntimeResult } from './toolRuntime';
-export type { VoiceToolContractCase, VoiceToolContractCaseReport, VoiceToolContractDefinition, VoiceToolContractExpectation, VoiceToolContractHandlerOptions, VoiceToolContractHTMLHandlerOptions, VoiceToolContractIssue, VoiceToolContractReport, VoiceToolContractRoutesOptions, VoiceToolContractSuiteReport } from './toolContract';
+export type { VoiceToolContractAssertionInput, VoiceToolContractAssertionReport, VoiceToolContractCase, VoiceToolContractCaseReport, VoiceToolContractDefinition, VoiceToolContractExpectation, VoiceToolContractHandlerOptions, VoiceToolContractHTMLHandlerOptions, VoiceToolContractIssue, VoiceToolContractReport, VoiceToolContractRoutesOptions, VoiceToolContractSuiteReport } from './toolContract';
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';
 export type { VoiceOutcomeRecipe, VoiceOutcomeRecipeName, VoiceOutcomeRecipeOptions } from './outcomeRecipes';

package/dist/index.js

@@ -14476,6 +14476,89 @@ var runVoiceOutcomeContractSuite = async (options) => {
     total: contracts.length
   };
 };
+var evaluateVoiceOutcomeContractEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxIssues = input.maxIssues ?? 0;
+  const contractIds = [
+    ...new Set(report.contracts.map((contract) => contract.contractId))
+  ].sort();
+  const issueCount = report.contracts.reduce((total, contract) => total + contract.issues.length, 0);
+  const totals = report.contracts.reduce((result, contract) => ({
+    handoffs: result.handoffs + contract.matched.handoffs,
+    integrationEvents: result.integrationEvents + contract.matched.integrationEvents,
+    operationsRecordHrefs: result.operationsRecordHrefs + contract.operationsRecordHrefs.length,
+    reviews: result.reviews + contract.matched.reviews,
+    sessions: result.sessions + contract.matched.sessions,
+    tasks: result.tasks + contract.matched.tasks
+  }), {
+    handoffs: 0,
+    integrationEvents: 0,
+    operationsRecordHrefs: 0,
+    reviews: 0,
+    sessions: 0,
+    tasks: 0
+  });
+  const contractsMissingOperationRecordHrefs = report.contracts.filter((contract) => contract.operationsRecordHrefs.length === 0).length;
+  if (input.minContracts !== undefined && report.total < input.minContracts) {
+    issues.push(`Expected at least ${String(input.minContracts)} outcome contract(s), found ${String(report.total)}.`);
+  }
+  if (report.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing outcome contract(s), found ${String(report.failed)}.`);
+  }
+  if (issueCount > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} outcome contract issue(s), found ${String(issueCount)}.`);
+  }
+  if (input.minSessions !== undefined && totals.sessions < input.minSessions) {
+    issues.push(`Expected at least ${String(input.minSessions)} matched outcome session(s), found ${String(totals.sessions)}.`);
+  }
+  if (input.minReviews !== undefined && totals.reviews < input.minReviews) {
+    issues.push(`Expected at least ${String(input.minReviews)} matched outcome review(s), found ${String(totals.reviews)}.`);
+  }
+  if (input.minTasks !== undefined && totals.tasks < input.minTasks) {
+    issues.push(`Expected at least ${String(input.minTasks)} matched outcome task(s), found ${String(totals.tasks)}.`);
+  }
+  if (input.minHandoffs !== undefined && totals.handoffs < input.minHandoffs) {
+    issues.push(`Expected at least ${String(input.minHandoffs)} matched outcome handoff(s), found ${String(totals.handoffs)}.`);
+  }
+  if (input.minIntegrationEvents !== undefined && totals.integrationEvents < input.minIntegrationEvents) {
+    issues.push(`Expected at least ${String(input.minIntegrationEvents)} matched outcome integration event(s), found ${String(totals.integrationEvents)}.`);
+  }
+  if (input.minOperationsRecordHrefs !== undefined && totals.operationsRecordHrefs < input.minOperationsRecordHrefs) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordHrefs)} outcome operations record href(s), found ${String(totals.operationsRecordHrefs)}.`);
+  }
+  if ((input.requireOperationRecordHrefs ?? false) && contractsMissingOperationRecordHrefs > 0) {
+    issues.push(`Expected every outcome contract to include operations record hrefs; ${String(contractsMissingOperationRecordHrefs)} contract(s) missing.`);
+  }
+  for (const contractId of input.requiredContractIds ?? []) {
+    if (!contractIds.includes(contractId)) {
+      issues.push(`Missing outcome contract: ${contractId}.`);
+    }
+  }
+  return {
+    contractIds,
+    failed: report.failed,
+    handoffs: totals.handoffs,
+    integrationEvents: totals.integrationEvents,
+    issues,
+    issueCount,
+    ok: issues.length === 0,
+    operationsRecordHrefs: totals.operationsRecordHrefs,
+    passed: report.passed,
+    reviews: totals.reviews,
+    sessions: totals.sessions,
+    status: report.status,
+    tasks: totals.tasks,
+    total: report.total
+  };
+};
+var assertVoiceOutcomeContractEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceOutcomeContractEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice outcome contract evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var renderVoiceOutcomeContractHTML = (report, options = {}) => {
   const title = options.title ?? "Voice Outcome Contracts";
   const contracts = report.contracts.map((contract) => {
@@ -14910,6 +14993,78 @@ var runVoiceToolContractSuite = async (options) => {
     total: contracts.length
   };
 };
+var evaluateVoiceToolContractEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxIssues = input.maxIssues ?? 0;
+  const maxTimedOut = input.maxTimedOut ?? Infinity;
+  const cases = report.contracts.flatMap((contract) => contract.cases);
+  const contractIds = [
+    ...new Set(report.contracts.map((contract) => contract.contractId))
+  ].sort();
+  const toolNames = [
+    ...new Set(report.contracts.map((contract) => contract.toolName))
+  ].sort();
+  const caseStatuses = [...new Set(cases.map((testCase) => testCase.status))].sort();
+  const issueCount = report.contracts.reduce((total, contract) => total + contract.issues.length, 0);
+  const timedOut = cases.filter((testCase) => testCase.timedOut).length;
+  const missingOperationsRecordHrefs = cases.filter((testCase) => !testCase.operationsRecordHref).length;
+  if (input.minContracts !== undefined && report.total < input.minContracts) {
+    issues.push(`Expected at least ${String(input.minContracts)} tool contract(s), found ${String(report.total)}.`);
+  }
+  if (input.minCases !== undefined && cases.length < input.minCases) {
+    issues.push(`Expected at least ${String(input.minCases)} tool contract case(s), found ${String(cases.length)}.`);
+  }
+  if (report.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing tool contract(s), found ${String(report.failed)}.`);
+  }
+  if (issueCount > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} tool contract issue(s), found ${String(issueCount)}.`);
+  }
+  if (timedOut > maxTimedOut) {
+    issues.push(`Expected at most ${String(maxTimedOut)} timed out tool contract case(s), found ${String(timedOut)}.`);
+  }
+  if ((input.requireOperationRecordHrefs ?? false) && missingOperationsRecordHrefs > 0) {
+    issues.push(`Expected every tool contract case to include an operations record href; ${String(missingOperationsRecordHrefs)} missing.`);
+  }
+  for (const contractId of input.requiredContractIds ?? []) {
+    if (!contractIds.includes(contractId)) {
+      issues.push(`Missing tool contract: ${contractId}.`);
+    }
+  }
+  for (const toolName of input.requiredToolNames ?? []) {
+    if (!toolNames.includes(toolName)) {
+      issues.push(`Missing tool contract tool: ${toolName}.`);
+    }
+  }
+  for (const status of input.requiredCaseStatuses ?? []) {
+    if (!caseStatuses.includes(status)) {
+      issues.push(`Missing tool contract case status: ${status}.`);
+    }
+  }
+  return {
+    caseStatuses,
+    cases: cases.length,
+    contractIds,
+    failed: report.failed,
+    issues,
+    issueCount,
+    missingOperationsRecordHrefs,
+    ok: issues.length === 0,
+    passed: report.passed,
+    status: report.status,
+    timedOut,
+    toolNames,
+    total: report.total
+  };
+};
+var assertVoiceToolContractEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceToolContractEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice tool contract evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var renderVoiceToolContractHTML = (report, options = {}) => {
   const title = options.title ?? "Voice Tool Contracts";
   const snippet = escapeHtml22(`app.use(
@@ -15125,6 +15280,61 @@ var runVoiceSimulationSuite = async (options) => {
     total: sections.length
   };
 };
+var simulationSectionNames = [
+  "fixtures",
+  "outcomes",
+  "scenarios",
+  "sessions",
+  "tools"
+];
+var evaluateVoiceSimulationSuiteEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxActions = input.maxActions ?? 0;
+  const sections = simulationSectionNames.filter((section) => report.summary[section] !== undefined);
+  const sectionTotals = Object.fromEntries(sections.map((section) => [section, report.summary[section]?.total ?? 0]));
+  if (report.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing simulation section(s), found ${String(report.failed)}.`);
+  }
+  if (report.actions.length > maxActions) {
+    issues.push(`Expected at most ${String(maxActions)} simulation action(s), found ${String(report.actions.length)}.`);
+  }
+  if (input.minSections !== undefined && report.total < input.minSections) {
+    issues.push(`Expected at least ${String(input.minSections)} simulation section(s), found ${String(report.total)}.`);
+  }
+  if (input.minPassed !== undefined && report.passed < input.minPassed) {
+    issues.push(`Expected at least ${String(input.minPassed)} passing simulation section(s), found ${String(report.passed)}.`);
+  }
+  for (const section of input.requiredSections ?? []) {
+    if (!sections.includes(section)) {
+      issues.push(`Missing simulation section: ${section}.`);
+    }
+  }
+  for (const [section, minimum] of Object.entries(input.sectionMinimums ?? {})) {
+    const total = sectionTotals[section] ?? 0;
+    if (total < minimum) {
+      issues.push(`Expected simulation section ${section} to include at least ${String(minimum)} item(s), found ${String(total)}.`);
+    }
+  }
+  return {
+    actions: report.actions.length,
+    failed: report.failed,
+    issues,
+    ok: issues.length === 0,
+    passed: report.passed,
+    sections,
+    sectionTotals,
+    status: report.status,
+    total: report.total
+  };
+};
+var assertVoiceSimulationSuiteEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceSimulationSuiteEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice simulation suite evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var renderSection = (label, summary) => {
   if (!summary) {
     return "";
@@ -30695,7 +30905,9 @@ export {
   exportVoiceTrace,
   exportVoiceAuditTrail,
   evaluateVoiceTrace,
+  evaluateVoiceToolContractEvidence,
   evaluateVoiceTelephonyContract,
+  evaluateVoiceSimulationSuiteEvidence,
   evaluateVoiceQuality,
   evaluateVoiceProviderStackGaps,
   evaluateVoiceProviderStackEvidence,
@@ -30705,6 +30917,7 @@ export {
   evaluateVoiceProofTrendEvidence,
   evaluateVoiceProductionReadinessEvidence,
   evaluateVoicePlatformCoverage,
+  evaluateVoiceOutcomeContractEvidence,
   evaluateVoiceOperationsRecordGuardrails,
   evaluateVoiceObservabilityExportReplayEvidence,
   evaluateVoiceObservabilityExportDeliveryEvidence,
@@ -31021,6 +31234,8 @@ export {
   buildVoiceAuditDeliveryReport,
   buildEmptyVoiceProofTrendReport,
   assignVoiceOpsTask,
+  assertVoiceToolContractEvidence,
+  assertVoiceSimulationSuiteEvidence,
   assertVoiceProviderStackEvidence,
   assertVoiceProviderSloEvidence,
   assertVoiceProviderRoutingContractEvidence,
@@ -31029,6 +31244,7 @@ export {
   assertVoiceProofTrendEvidence,
   assertVoiceProductionReadinessEvidence,
   assertVoicePlatformCoverage,
+  assertVoiceOutcomeContractEvidence,
   assertVoiceOperationsRecordGuardrails,
   assertVoiceObservabilityExportSchema,
   assertVoiceObservabilityExportReplayEvidence,

package/dist/outcomeContract.d.ts

@@ -44,6 +44,35 @@ export type VoiceOutcomeContractSuiteReport = {
     status: VoiceOutcomeContractStatus;
     total: number;
 };
+export type VoiceOutcomeContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minHandoffs?: number;
+    minIntegrationEvents?: number;
+    minOperationsRecordHrefs?: number;
+    minReviews?: number;
+    minSessions?: number;
+    minTasks?: number;
+    requiredContractIds?: string[];
+    requireOperationRecordHrefs?: boolean;
+};
+export type VoiceOutcomeContractAssertionReport = {
+    contractIds: string[];
+    failed: number;
+    handoffs: number;
+    integrationEvents: number;
+    issues: string[];
+    issueCount: number;
+    ok: boolean;
+    operationsRecordHrefs: number;
+    passed: number;
+    reviews: number;
+    sessions: number;
+    status: VoiceOutcomeContractStatus;
+    tasks: number;
+    total: number;
+};
 type ListStore<T> = {
     list: () => Promise<T[]> | T[];
 };
@@ -67,6 +96,8 @@ export type VoiceOutcomeContractRoutesOptions<TSession extends VoiceSessionRecor
     path?: string;
 };
 export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const evaluateVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
+export declare const assertVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
 export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
     title?: string;
 }) => string;

package/dist/simulationSuite.d.ts

@@ -39,6 +39,26 @@ export type VoiceSimulationSuiteSectionSummary = {
     status: VoiceSimulationSuiteStatus;
     total: number;
 };
+export type VoiceSimulationSuiteSection = 'fixtures' | 'outcomes' | 'scenarios' | 'sessions' | 'tools';
+export type VoiceSimulationSuiteAssertionInput = {
+    maxActions?: number;
+    maxFailed?: number;
+    minPassed?: number;
+    minSections?: number;
+    requiredSections?: VoiceSimulationSuiteSection[];
+    sectionMinimums?: Partial<Record<VoiceSimulationSuiteSection, number>>;
+};
+export type VoiceSimulationSuiteAssertionReport = {
+    actions: number;
+    failed: number;
+    issues: string[];
+    ok: boolean;
+    passed: number;
+    sections: VoiceSimulationSuiteSection[];
+    sectionTotals: Partial<Record<VoiceSimulationSuiteSection, number>>;
+    status: VoiceSimulationSuiteStatus;
+    total: number;
+};
 export type VoiceSimulationSuiteOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
     actionLinks?: {
         fixtures?: string;
@@ -75,6 +95,8 @@ export type VoiceSimulationSuiteRoutesOptions<TSession extends VoiceSessionRecor
     title?: string;
 };
 export declare const runVoiceSimulationSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceSimulationSuiteOptions<TSession>) => Promise<VoiceSimulationSuiteReport>;
+export declare const evaluateVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
+export declare const assertVoiceSimulationSuiteEvidence: (report: VoiceSimulationSuiteReport, input?: VoiceSimulationSuiteAssertionInput) => VoiceSimulationSuiteAssertionReport;
 export declare const renderVoiceSimulationSuiteHTML: (report: VoiceSimulationSuiteReport, options?: {
     title?: string;
 }) => string;

package/dist/toolContract.d.ts

@@ -64,6 +64,32 @@ export type VoiceToolContractSuiteReport = {
     status: 'fail' | 'pass';
     total: number;
 };
+export type VoiceToolContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    maxTimedOut?: number;
+    minCases?: number;
+    minContracts?: number;
+    requireOperationRecordHrefs?: boolean;
+    requiredCaseStatuses?: Array<'error' | 'ok'>;
+    requiredContractIds?: string[];
+    requiredToolNames?: string[];
+};
+export type VoiceToolContractAssertionReport = {
+    caseStatuses: Array<'error' | 'ok'>;
+    cases: number;
+    contractIds: string[];
+    failed: number;
+    issues: string[];
+    issueCount: number;
+    missingOperationsRecordHrefs: number;
+    ok: boolean;
+    passed: number;
+    status: VoiceToolContractSuiteReport['status'];
+    timedOut: number;
+    toolNames: string[];
+    total: number;
+};
 export type VoiceToolContractHandlerOptions = {
     contracts: VoiceToolContractDefinition[];
     operationsRecordHref?: false | string | ((sessionId: string) => string);
@@ -86,6 +112,8 @@ export declare const createVoiceToolContract: <TContext = unknown, TSession exte
 };
 export declare const createVoiceToolRuntimeContractDefaults: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown>() => VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>;
 export declare const runVoiceToolContractSuite: (options: VoiceToolContractHandlerOptions) => Promise<VoiceToolContractSuiteReport>;
+export declare const evaluateVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
+export declare const assertVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
 export declare const renderVoiceToolContractHTML: (report: VoiceToolContractSuiteReport, options?: {
     title?: string;
 }) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.255",
+	"version": "0.0.22-beta.257",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",