@absolutejs/voice 0.0.22-beta.260 → 0.0.22-beta.261

package/dist/angular/voice-live-ops.service.d.ts

@@ -6,6 +6,6 @@ export declare class VoiceLiveOpsService {
         isRunning: import("@angular/core").Signal<boolean>;
         lastResult: import("@angular/core").Signal<VoiceLiveOpsActionResult | undefined>;
         run: (input: import("..").VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult | undefined>;
-        runningAction: import("@angular/core").Signal<"assign" | "create-task" | "escalate" | "force-handoff" | "inject-instruction" | "operator-takeover" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
+        runningAction: import("@angular/core").Signal<"escalate" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "operator-takeover" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
     };
 }

package/dist/client/index.js

@@ -4206,6 +4206,99 @@ var VOICE_LIVE_OPS_ACTIONS = [
 ];
 var isVoiceLiveOpsAction = (value) => typeof value === "string" && VOICE_LIVE_OPS_ACTIONS.includes(value);
 var toStringValue = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var findMissing = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
+var evaluateVoiceLiveOpsEvidence = (input = {}) => {
+  const issues = [];
+  const actionHistory = input.actionHistory;
+  const opsRecovery = input.opsRecovery;
+  const opsStatus = input.opsStatus;
+  const operationsRecord = input.operationsRecord;
+  const historyActions = uniqueSorted(actionHistory?.entries.map((entry) => entry.actionId) ?? []);
+  const interventionActions = uniqueSorted(opsRecovery?.interventions.events.map((event) => event.action).filter((action) => Boolean(action)) ?? []);
+  const requireActionHistory = input.requireActionHistory ?? true;
+  const requireOperationsRecord = input.requireOperationsRecord ?? true;
+  const requireOpsRecovery = input.requireOpsRecovery ?? true;
+  const requireOpsRecoveryStatus = input.requireOpsRecoveryStatus ?? "pass";
+  const requireOpsStatus = input.requireOpsStatus ?? true;
+  const requireOpsStatusPass = input.requireOpsStatusPass ?? true;
+  if (requireActionHistory && !actionHistory) {
+    issues.push("Expected live-ops action history report to be present.");
+  }
+  if (requireOpsRecovery && !opsRecovery) {
+    issues.push("Expected ops recovery report to be present.");
+  }
+  if (requireOpsStatus && !opsStatus) {
+    issues.push("Expected ops status report to be present.");
+  }
+  if (requireOperationsRecord && !operationsRecord) {
+    issues.push("Expected operations record to be present.");
+  }
+  if (opsRecovery && opsRecovery.status !== requireOpsRecoveryStatus) {
+    issues.push(`Expected ops recovery status ${requireOpsRecoveryStatus}, found ${opsRecovery.status}.`);
+  }
+  if (opsRecovery && input.maxOpsRecoveryIssues !== undefined && opsRecovery.issues.length > input.maxOpsRecoveryIssues) {
+    issues.push(`Expected at most ${String(input.maxOpsRecoveryIssues)} ops recovery issue(s), found ${String(opsRecovery.issues.length)}.`);
+  }
+  if (opsRecovery && input.minInterventions !== undefined && opsRecovery.interventions.total < input.minInterventions) {
+    issues.push(`Expected at least ${String(input.minInterventions)} live-ops intervention(s), found ${String(opsRecovery.interventions.total)}.`);
+  }
+  for (const action of findMissing(interventionActions, input.requiredInterventionActions)) {
+    issues.push(`Missing live-ops intervention action: ${action}.`);
+  }
+  if (opsStatus && requireOpsStatusPass && opsStatus.status !== "pass") {
+    issues.push(`Expected ops status pass, found ${opsStatus.status}.`);
+  }
+  if (actionHistory && input.minActionHistoryEntries !== undefined && actionHistory.total < input.minActionHistoryEntries) {
+    issues.push(`Expected at least ${String(input.minActionHistoryEntries)} operator action history entrie(s), found ${String(actionHistory.total)}.`);
+  }
+  if (actionHistory && input.maxActionHistoryFailures !== undefined && actionHistory.failed > input.maxActionHistoryFailures) {
+    issues.push(`Expected at most ${String(input.maxActionHistoryFailures)} failed operator action(s), found ${String(actionHistory.failed)}.`);
+  }
+  for (const action of findMissing(historyActions, input.requiredHistoryActions)) {
+    issues.push(`Missing operator action history action: ${action}.`);
+  }
+  if (operationsRecord && input.requireOperationsRecordHealthy !== false && operationsRecord.status === "failed") {
+    issues.push("Expected operations record not to be failed.");
+  }
+  if (operationsRecord && input.requireOperationsRecordAudit && !operationsRecord.audit) {
+    issues.push("Expected operations record audit summary to be present.");
+  }
+  if (operationsRecord && input.minOperationsRecordHandoffs !== undefined && operationsRecord.handoffs.length < input.minOperationsRecordHandoffs) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordHandoffs)} operations-record handoff(s), found ${String(operationsRecord.handoffs.length)}.`);
+  }
+  if (operationsRecord && input.minOperationsRecordTasks !== undefined && (operationsRecord.tasks?.total ?? 0) < input.minOperationsRecordTasks) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordTasks)} operations-record task(s), found ${String(operationsRecord.tasks?.total ?? 0)}.`);
+  }
+  return {
+    actionHistoryFailed: actionHistory?.failed,
+    actionHistoryTotal: actionHistory?.total,
+    historyActions,
+    interventionActions,
+    interventions: opsRecovery?.interventions.total,
+    issues,
+    ok: issues.length === 0,
+    operationsRecordHandoffs: operationsRecord?.handoffs.length,
+    operationsRecordStatus: operationsRecord?.status,
+    operationsRecordTasks: operationsRecord?.tasks?.total,
+    opsRecoveryIssues: opsRecovery?.issues.length,
+    opsRecoveryStatus: opsRecovery?.status,
+    opsStatus: opsStatus?.status
+  };
+};
+var assertVoiceLiveOpsEvidence = (input = {}) => {
+  const assertion = evaluateVoiceLiveOpsEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice live-ops evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceMemoryLiveOpsControlStore = () => {
   const states = new Map;
   return {

package/dist/index.d.ts

@@ -18,8 +18,8 @@ export { assertVoicePlatformCoverage, buildVoicePlatformCoverageSummary, createV
 export type { VoicePlatformCoverageAssertionInput, VoicePlatformCoverageAssertionReport, VoicePlatformCoverageEvidence, VoicePlatformCoverageRoutesOptions, VoicePlatformCoverageStatus, VoicePlatformCoverageSummary, VoicePlatformCoverageSummaryInput, VoicePlatformCoverageSurface } from './platformCoverage';
 export { assertVoiceProofTrendEvidence, buildEmptyVoiceProofTrendReport, buildVoiceProofTrendReport, createVoiceProofTrendRoutes, DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS, evaluateVoiceProofTrendEvidence, formatVoiceProofTrendAge, normalizeVoiceProofTrendReport, readVoiceProofTrendReportFile } from './proofTrends';
 export type { VoiceProofTrendAssertionInput, VoiceProofTrendAssertionReport, VoiceProofTrendCycle, VoiceProofTrendReport, VoiceProofTrendReportInput, VoiceProofTrendRoutesOptions, VoiceProofTrendStatus, VoiceProofTrendSummary } from './proofTrends';
-export { buildVoiceLiveOpsControlState, createVoiceLiveOpsController, createVoiceLiveOpsRoutes, createVoiceMemoryLiveOpsControlStore, getVoiceLiveOpsControlStatus, VOICE_LIVE_OPS_ACTIONS } from './liveOps';
-export type { VoiceLiveOpsAction, VoiceLiveOpsActionInput, VoiceLiveOpsActionResult, VoiceLiveOpsControllerOptions, VoiceLiveOpsControlState, VoiceLiveOpsControlStatus, VoiceLiveOpsControlStore, VoiceLiveOpsRoutesOptions } from './liveOps';
+export { assertVoiceLiveOpsEvidence, buildVoiceLiveOpsControlState, createVoiceLiveOpsController, createVoiceLiveOpsRoutes, createVoiceMemoryLiveOpsControlStore, evaluateVoiceLiveOpsEvidence, getVoiceLiveOpsControlStatus, VOICE_LIVE_OPS_ACTIONS } from './liveOps';
+export type { VoiceLiveOpsAction, VoiceLiveOpsActionInput, VoiceLiveOpsActionResult, VoiceLiveOpsControllerOptions, VoiceLiveOpsControlState, VoiceLiveOpsControlStatus, VoiceLiveOpsControlStore, VoiceLiveOpsEvidenceInput, VoiceLiveOpsEvidenceReport, VoiceLiveOpsRoutesOptions } from './liveOps';
 export { buildVoiceDeliveryRuntimeReport, createVoiceDeliveryRuntime, createVoiceDeliveryRuntimePresetConfig, createVoiceDeliveryRuntimeRoutes, renderVoiceDeliveryRuntimeHTML } from './deliveryRuntime';
 export { applyVoiceDataRetentionPolicy, assertVoiceDataControlEvidence, buildVoiceDataControlReport, buildVoiceDataRetentionPlan, createVoiceDataControlRoutes, createVoiceZeroRetentionPolicy, evaluateVoiceDataControlEvidence, renderVoiceDataControlHTML, renderVoiceDataControlMarkdown, voiceComplianceRedactionDefaults } from './dataControl';
 export type { VoiceDataControlAssertionInput, VoiceDataControlAssertionReport, VoiceDataControlProviderKeySurface, VoiceDataControlReport, VoiceDataControlRoutesOptions, VoiceDataControlStorageSurface, VoiceDataRetentionPolicy, VoiceDataRetentionReport, VoiceDataRetentionScope, VoiceDataRetentionScopeReport, VoiceDataRetentionStores } from './dataControl';

package/dist/index.js

@@ -12636,6 +12636,99 @@ var VOICE_LIVE_OPS_ACTIONS = [
 ];
 var isVoiceLiveOpsAction = (value) => typeof value === "string" && VOICE_LIVE_OPS_ACTIONS.includes(value);
 var toStringValue = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var findMissing = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
+var evaluateVoiceLiveOpsEvidence = (input = {}) => {
+  const issues = [];
+  const actionHistory = input.actionHistory;
+  const opsRecovery = input.opsRecovery;
+  const opsStatus = input.opsStatus;
+  const operationsRecord = input.operationsRecord;
+  const historyActions = uniqueSorted(actionHistory?.entries.map((entry) => entry.actionId) ?? []);
+  const interventionActions = uniqueSorted(opsRecovery?.interventions.events.map((event) => event.action).filter((action) => Boolean(action)) ?? []);
+  const requireActionHistory = input.requireActionHistory ?? true;
+  const requireOperationsRecord = input.requireOperationsRecord ?? true;
+  const requireOpsRecovery = input.requireOpsRecovery ?? true;
+  const requireOpsRecoveryStatus = input.requireOpsRecoveryStatus ?? "pass";
+  const requireOpsStatus = input.requireOpsStatus ?? true;
+  const requireOpsStatusPass = input.requireOpsStatusPass ?? true;
+  if (requireActionHistory && !actionHistory) {
+    issues.push("Expected live-ops action history report to be present.");
+  }
+  if (requireOpsRecovery && !opsRecovery) {
+    issues.push("Expected ops recovery report to be present.");
+  }
+  if (requireOpsStatus && !opsStatus) {
+    issues.push("Expected ops status report to be present.");
+  }
+  if (requireOperationsRecord && !operationsRecord) {
+    issues.push("Expected operations record to be present.");
+  }
+  if (opsRecovery && opsRecovery.status !== requireOpsRecoveryStatus) {
+    issues.push(`Expected ops recovery status ${requireOpsRecoveryStatus}, found ${opsRecovery.status}.`);
+  }
+  if (opsRecovery && input.maxOpsRecoveryIssues !== undefined && opsRecovery.issues.length > input.maxOpsRecoveryIssues) {
+    issues.push(`Expected at most ${String(input.maxOpsRecoveryIssues)} ops recovery issue(s), found ${String(opsRecovery.issues.length)}.`);
+  }
+  if (opsRecovery && input.minInterventions !== undefined && opsRecovery.interventions.total < input.minInterventions) {
+    issues.push(`Expected at least ${String(input.minInterventions)} live-ops intervention(s), found ${String(opsRecovery.interventions.total)}.`);
+  }
+  for (const action of findMissing(interventionActions, input.requiredInterventionActions)) {
+    issues.push(`Missing live-ops intervention action: ${action}.`);
+  }
+  if (opsStatus && requireOpsStatusPass && opsStatus.status !== "pass") {
+    issues.push(`Expected ops status pass, found ${opsStatus.status}.`);
+  }
+  if (actionHistory && input.minActionHistoryEntries !== undefined && actionHistory.total < input.minActionHistoryEntries) {
+    issues.push(`Expected at least ${String(input.minActionHistoryEntries)} operator action history entrie(s), found ${String(actionHistory.total)}.`);
+  }
+  if (actionHistory && input.maxActionHistoryFailures !== undefined && actionHistory.failed > input.maxActionHistoryFailures) {
+    issues.push(`Expected at most ${String(input.maxActionHistoryFailures)} failed operator action(s), found ${String(actionHistory.failed)}.`);
+  }
+  for (const action of findMissing(historyActions, input.requiredHistoryActions)) {
+    issues.push(`Missing operator action history action: ${action}.`);
+  }
+  if (operationsRecord && input.requireOperationsRecordHealthy !== false && operationsRecord.status === "failed") {
+    issues.push("Expected operations record not to be failed.");
+  }
+  if (operationsRecord && input.requireOperationsRecordAudit && !operationsRecord.audit) {
+    issues.push("Expected operations record audit summary to be present.");
+  }
+  if (operationsRecord && input.minOperationsRecordHandoffs !== undefined && operationsRecord.handoffs.length < input.minOperationsRecordHandoffs) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordHandoffs)} operations-record handoff(s), found ${String(operationsRecord.handoffs.length)}.`);
+  }
+  if (operationsRecord && input.minOperationsRecordTasks !== undefined && (operationsRecord.tasks?.total ?? 0) < input.minOperationsRecordTasks) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordTasks)} operations-record task(s), found ${String(operationsRecord.tasks?.total ?? 0)}.`);
+  }
+  return {
+    actionHistoryFailed: actionHistory?.failed,
+    actionHistoryTotal: actionHistory?.total,
+    historyActions,
+    interventionActions,
+    interventions: opsRecovery?.interventions.total,
+    issues,
+    ok: issues.length === 0,
+    operationsRecordHandoffs: operationsRecord?.handoffs.length,
+    operationsRecordStatus: operationsRecord?.status,
+    operationsRecordTasks: operationsRecord?.tasks?.total,
+    opsRecoveryIssues: opsRecovery?.issues.length,
+    opsRecoveryStatus: opsRecovery?.status,
+    opsStatus: opsStatus?.status
+  };
+};
+var assertVoiceLiveOpsEvidence = (input = {}) => {
+  const assertion = evaluateVoiceLiveOpsEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice live-ops evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceMemoryLiveOpsControlStore = () => {
   const states = new Map;
   return {
@@ -13422,8 +13515,8 @@ var defaultProviderKeys = [
   }
 ];
 var resolveDataControlRedaction = (redact) => redact === false ? undefined : redact === true || redact === undefined ? voiceComplianceRedactionDefaults : redact;
-var uniqueSorted = (values) => Array.from(new Set(values)).sort();
-var findMissing = (values, required) => {
+var uniqueSorted2 = (values) => Array.from(new Set(values)).sort();
+var findMissing2 = (values, required) => {
   if (!required?.length) {
     return [];
   }
@@ -13434,10 +13527,10 @@ var evaluateVoiceDataControlEvidence = (report, input = {}) => {
   const issues = [];
   const configuredStorage = report.storage.filter((surface) => surface.configured).map((surface) => surface.name);
   const selfHostedConfiguredStorage = report.storage.filter((surface) => surface.configured && surface.selfHosted).map((surface) => surface.name);
-  const controls = uniqueSorted(report.storage.filter((surface) => surface.configured).map((surface) => surface.control));
-  const retentionScopes = uniqueSorted(report.retentionPlan.scopes.map((scope) => scope.scope));
-  const deletionScopes = uniqueSorted(report.deletionProof?.scopes.map((scope) => scope.scope) ?? []);
-  const providerKeys = uniqueSorted(report.providerKeys.map((key) => key.name.toLowerCase()));
+  const controls = uniqueSorted2(report.storage.filter((surface) => surface.configured).map((surface) => surface.control));
+  const retentionScopes = uniqueSorted2(report.retentionPlan.scopes.map((scope) => scope.scope));
+  const deletionScopes = uniqueSorted2(report.deletionProof?.scopes.map((scope) => scope.scope) ?? []);
+  const providerKeys = uniqueSorted2(report.providerKeys.map((key) => key.name.toLowerCase()));
   const auditExportEvents = report.auditExport?.events.length ?? 0;
   const deletionDeleted = report.deletionProof?.deletedCount ?? 0;
   const maxRetentionDeleted = input.maxRetentionDeleted;
@@ -13485,14 +13578,14 @@ var evaluateVoiceDataControlEvidence = (report, input = {}) => {
       issues.push(`Expected configured storage to be self-hosted, found ${String(nonSelfHostedConfigured)} non-self-hosted surfaces.`);
     }
   }
-  const missingConfiguredStorage = findMissing(configuredStorage, input.requiredStorage);
+  const missingConfiguredStorage = findMissing2(configuredStorage, input.requiredStorage);
   if (missingConfiguredStorage.length > (input.maxMissingConfiguredStorage ?? 0)) {
     issues.push(`Missing configured storage surfaces: ${missingConfiguredStorage.join(", ")}.`);
   }
-  for (const control of findMissing(controls, input.requiredControls)) {
+  for (const control of findMissing2(controls, input.requiredControls)) {
     issues.push(`Missing configured storage control: ${control}.`);
   }
-  for (const scope of findMissing(retentionScopes, input.requiredRetentionScopes)) {
+  for (const scope of findMissing2(retentionScopes, input.requiredRetentionScopes)) {
     issues.push(`Missing retention scope: ${scope}.`);
   }
   for (const scope of input.requiredRetentionScopes ?? []) {
@@ -13501,7 +13594,7 @@ var evaluateVoiceDataControlEvidence = (report, input = {}) => {
       issues.push(`Retention scope ${scope} was skipped: ${retentionScope.skippedReason}.`);
     }
   }
-  for (const scope of findMissing(deletionScopes, input.requiredDeletionScopes)) {
+  for (const scope of findMissing2(deletionScopes, input.requiredDeletionScopes)) {
     issues.push(`Missing deletion-proof scope: ${scope}.`);
   }
   for (const scope of input.requiredDeletionScopes ?? []) {
@@ -19875,8 +19968,8 @@ var loadCarrierMatrixInputs = async (input) => {
 };
 var carrierAnswerLabel = (provider) => provider === "telnyx" ? "TeXML URL" : provider === "plivo" ? "Answer URL" : "TwiML URL";
 var findCarrierMatrixEntry = (matrix, carrier) => matrix?.entries.find((candidate) => candidate.provider === carrier.provider && (candidate.name === carrier.name || candidate.name === (carrier.name ?? carrier.provider)));
-var uniqueSorted2 = (values) => Array.from(new Set(values)).sort();
-var findMissing2 = (values, required) => {
+var uniqueSorted3 = (values) => Array.from(new Set(values)).sort();
+var findMissing3 = (values, required) => {
   if (!required?.length) {
     return [];
   }
@@ -19885,8 +19978,8 @@ var findMissing2 = (values, required) => {
 };
 var evaluateVoicePhoneAssistantEvidence = (report, input = {}) => {
   const issues = [];
-  const providers = uniqueSorted2(report.carriers.map((carrier) => carrier.provider));
-  const lifecycleStages = uniqueSorted2(report.lifecycleStages);
+  const providers = uniqueSorted3(report.carriers.map((carrier) => carrier.provider));
+  const lifecycleStages = uniqueSorted3(report.lifecycleStages);
   const carrierSummary = report.matrix?.summary;
   const carrierFailures = carrierSummary?.failing ?? 0;
   const carrierWarnings = carrierSummary?.warnings ?? 0;
@@ -19926,10 +20019,10 @@ var evaluateVoicePhoneAssistantEvidence = (report, input = {}) => {
   if (input.maxCarrierWarnings !== undefined && carrierWarnings > input.maxCarrierWarnings) {
     issues.push(`Expected at most ${String(input.maxCarrierWarnings)} phone carrier warning(s), found ${String(carrierWarnings)}.`);
   }
-  for (const provider of findMissing2(providers, input.requiredProviders)) {
+  for (const provider of findMissing3(providers, input.requiredProviders)) {
     issues.push(`Missing phone carrier provider: ${provider}.`);
   }
-  for (const stage of findMissing2(lifecycleStages, input.requiredLifecycleStages)) {
+  for (const stage of findMissing3(lifecycleStages, input.requiredLifecycleStages)) {
     issues.push(`Missing phone lifecycle stage: ${stage}.`);
   }
   const dialer = input.dialerProof ? evaluateVoiceCampaignDialerProofEvidence(input.dialerProof, {
@@ -22900,7 +22993,7 @@ var statusRank = {
 var escapeHtml36 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var roundMetric3 = (value) => Math.round(value * 1e4) / 1e4;
 var rate3 = (count, total) => count / Math.max(1, total);
-var uniqueSorted3 = (values) => [
+var uniqueSorted4 = (values) => [
   ...new Set(values.filter((value) => typeof value === "string"))
 ].sort();
 var percentile3 = (values, rank) => {
@@ -23083,7 +23176,7 @@ var buildVoiceProviderSloReport = async (options = {}) => {
 var evaluateVoiceProviderSloEvidence = (report, input = {}) => {
   const issues = [];
   const kindReports = Object.values(report.kinds);
-  const providers = uniqueSorted3(kindReports.flatMap((kind) => kind.providers));
+  const providers = uniqueSorted4(kindReports.flatMap((kind) => kind.providers));
   const kinds = providerKinds.filter((kind) => report.kinds[kind].events > 0);
   const fallbacks = kindReports.reduce((total, kind) => total + kind.fallbacks, 0);
   const timeouts = kindReports.reduce((total, kind) => total + kind.timeouts, 0);
@@ -23804,7 +23897,7 @@ var hasPayloadValue = (payload, key, values) => {
   return typeof value === "string" && values.has(value);
 };
 var countIntegrationDeliveryStatus = (events, status) => events.filter((event) => event.deliveryStatus === status).length;
-var uniqueSorted4 = (values) => [
+var uniqueSorted5 = (values) => [
   ...new Set(values.filter((value) => typeof value === "string"))
 ].sort();
 var pushMissingValuesIssue = (input) => {
@@ -23983,11 +24076,11 @@ var buildVoiceOperationsRecord = async (options) => {
 var evaluateVoiceOperationsRecordGuardrails = (record, input = {}) => {
   const issues = [];
   const decisions = record.guardrails.decisions;
-  const proofs = uniqueSorted4(decisions.map((decision) => decision.proof));
-  const ruleIds = uniqueSorted4(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
-  const stages = uniqueSorted4(decisions.map((decision) => decision.stage));
-  const statuses = uniqueSorted4(decisions.map((decision) => decision.status));
-  const toolNames = uniqueSorted4(decisions.map((decision) => decision.toolName));
+  const proofs = uniqueSorted5(decisions.map((decision) => decision.proof));
+  const ruleIds = uniqueSorted5(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
+  const stages = uniqueSorted5(decisions.map((decision) => decision.stage));
+  const statuses = uniqueSorted5(decisions.map((decision) => decision.status));
+  const toolNames = uniqueSorted5(decisions.map((decision) => decision.toolName));
   const minDecisions = input.minDecisions ?? 1;
   if (record.guardrails.total < minDecisions) {
     issues.push(`Expected at least ${String(minDecisions)} guardrail decisions, found ${String(record.guardrails.total)}.`);
@@ -31240,6 +31333,7 @@ export {
   evaluateVoiceOperationsRecordGuardrails,
   evaluateVoiceObservabilityExportReplayEvidence,
   evaluateVoiceObservabilityExportDeliveryEvidence,
+  evaluateVoiceLiveOpsEvidence,
   evaluateVoiceGuardrailPolicy,
   evaluateVoiceDataControlEvidence,
   evaluateVoiceCampaignReadinessEvidence,
@@ -31573,6 +31667,7 @@ export {
   assertVoiceObservabilityExportReplayEvidence,
   assertVoiceObservabilityExportRecord,
   assertVoiceObservabilityExportDeliveryEvidence,
+  assertVoiceLiveOpsEvidence,
   assertVoiceLatencySLOGate,
   assertVoiceDataControlEvidence,
   assertVoiceCampaignReadinessEvidence,

package/dist/liveOps.d.ts

@@ -1,6 +1,10 @@
 import { Elysia } from 'elysia';
 import { type VoiceAuditEventStore } from './audit';
 import { type VoiceTraceEventStore } from './trace';
+import type { VoiceOperationsRecord } from './operationsRecord';
+import type { VoiceOpsActionHistoryReport } from './opsActionAuditRoutes';
+import type { VoiceOpsRecoveryReport, VoiceOpsRecoveryStatus } from './opsRecovery';
+import type { VoiceOpsStatusReport } from './opsStatus';
 export declare const VOICE_LIVE_OPS_ACTIONS: readonly ["assign", "create-task", "escalate", "force-handoff", "inject-instruction", "operator-takeover", "pause-assistant", "resume-assistant", "tag"];
 export type VoiceLiveOpsAction = (typeof VOICE_LIVE_OPS_ACTIONS)[number];
 export type VoiceLiveOpsControlStatus = 'assistant-paused' | 'assistant-resumed' | 'handoff-forced' | 'instruction-injected' | 'operator-takeover' | 'recorded';
@@ -28,6 +32,43 @@ export type VoiceLiveOpsActionResult = {
     ok: true;
     sessionId: string;
 };
+export type VoiceLiveOpsEvidenceInput = {
+    actionHistory?: VoiceOpsActionHistoryReport;
+    maxActionHistoryFailures?: number;
+    maxOpsRecoveryIssues?: number;
+    minActionHistoryEntries?: number;
+    minInterventions?: number;
+    minOperationsRecordHandoffs?: number;
+    minOperationsRecordTasks?: number;
+    operationsRecord?: VoiceOperationsRecord;
+    opsRecovery?: VoiceOpsRecoveryReport;
+    opsStatus?: VoiceOpsStatusReport;
+    requireActionHistory?: boolean;
+    requireOperationsRecord?: boolean;
+    requireOperationsRecordAudit?: boolean;
+    requireOperationsRecordHealthy?: boolean;
+    requireOpsRecovery?: boolean;
+    requireOpsRecoveryStatus?: VoiceOpsRecoveryStatus;
+    requireOpsStatus?: boolean;
+    requireOpsStatusPass?: boolean;
+    requiredHistoryActions?: string[];
+    requiredInterventionActions?: string[];
+};
+export type VoiceLiveOpsEvidenceReport = {
+    actionHistoryFailed?: number;
+    actionHistoryTotal?: number;
+    historyActions: string[];
+    interventionActions: string[];
+    interventions?: number;
+    issues: string[];
+    ok: boolean;
+    operationsRecordHandoffs?: number;
+    operationsRecordStatus?: VoiceOperationsRecord['status'];
+    operationsRecordTasks?: number;
+    opsRecoveryIssues?: number;
+    opsRecoveryStatus?: VoiceOpsRecoveryStatus;
+    opsStatus?: VoiceOpsStatusReport['status'];
+};
 export type VoiceLiveOpsControlStore = {
     get: (sessionId: string) => Promise<VoiceLiveOpsControlState | undefined> | VoiceLiveOpsControlState | undefined;
     set: (sessionId: string, state: VoiceLiveOpsControlState) => Promise<void> | void;
@@ -50,6 +91,8 @@ export type VoiceLiveOpsRoutesOptions = VoiceLiveOpsControllerOptions & {
     name?: string;
     path?: string;
 };
+export declare const evaluateVoiceLiveOpsEvidence: (input?: VoiceLiveOpsEvidenceInput) => VoiceLiveOpsEvidenceReport;
+export declare const assertVoiceLiveOpsEvidence: (input?: VoiceLiveOpsEvidenceInput) => VoiceLiveOpsEvidenceReport;
 export declare const createVoiceMemoryLiveOpsControlStore: () => VoiceLiveOpsControlStore;
 export declare const getVoiceLiveOpsControlStatus: (action: VoiceLiveOpsAction) => VoiceLiveOpsControlStatus;
 export declare const buildVoiceLiveOpsControlState: (input: VoiceLiveOpsActionInput & {

package/dist/svelte/index.js

@@ -1744,6 +1744,99 @@ var VOICE_LIVE_OPS_ACTIONS = [
 ];
 var isVoiceLiveOpsAction = (value) => typeof value === "string" && VOICE_LIVE_OPS_ACTIONS.includes(value);
 var toStringValue = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var findMissing = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
+var evaluateVoiceLiveOpsEvidence = (input = {}) => {
+  const issues = [];
+  const actionHistory = input.actionHistory;
+  const opsRecovery = input.opsRecovery;
+  const opsStatus = input.opsStatus;
+  const operationsRecord = input.operationsRecord;
+  const historyActions = uniqueSorted(actionHistory?.entries.map((entry) => entry.actionId) ?? []);
+  const interventionActions = uniqueSorted(opsRecovery?.interventions.events.map((event) => event.action).filter((action) => Boolean(action)) ?? []);
+  const requireActionHistory = input.requireActionHistory ?? true;
+  const requireOperationsRecord = input.requireOperationsRecord ?? true;
+  const requireOpsRecovery = input.requireOpsRecovery ?? true;
+  const requireOpsRecoveryStatus = input.requireOpsRecoveryStatus ?? "pass";
+  const requireOpsStatus = input.requireOpsStatus ?? true;
+  const requireOpsStatusPass = input.requireOpsStatusPass ?? true;
+  if (requireActionHistory && !actionHistory) {
+    issues.push("Expected live-ops action history report to be present.");
+  }
+  if (requireOpsRecovery && !opsRecovery) {
+    issues.push("Expected ops recovery report to be present.");
+  }
+  if (requireOpsStatus && !opsStatus) {
+    issues.push("Expected ops status report to be present.");
+  }
+  if (requireOperationsRecord && !operationsRecord) {
+    issues.push("Expected operations record to be present.");
+  }
+  if (opsRecovery && opsRecovery.status !== requireOpsRecoveryStatus) {
+    issues.push(`Expected ops recovery status ${requireOpsRecoveryStatus}, found ${opsRecovery.status}.`);
+  }
+  if (opsRecovery && input.maxOpsRecoveryIssues !== undefined && opsRecovery.issues.length > input.maxOpsRecoveryIssues) {
+    issues.push(`Expected at most ${String(input.maxOpsRecoveryIssues)} ops recovery issue(s), found ${String(opsRecovery.issues.length)}.`);
+  }
+  if (opsRecovery && input.minInterventions !== undefined && opsRecovery.interventions.total < input.minInterventions) {
+    issues.push(`Expected at least ${String(input.minInterventions)} live-ops intervention(s), found ${String(opsRecovery.interventions.total)}.`);
+  }
+  for (const action of findMissing(interventionActions, input.requiredInterventionActions)) {
+    issues.push(`Missing live-ops intervention action: ${action}.`);
+  }
+  if (opsStatus && requireOpsStatusPass && opsStatus.status !== "pass") {
+    issues.push(`Expected ops status pass, found ${opsStatus.status}.`);
+  }
+  if (actionHistory && input.minActionHistoryEntries !== undefined && actionHistory.total < input.minActionHistoryEntries) {
+    issues.push(`Expected at least ${String(input.minActionHistoryEntries)} operator action history entrie(s), found ${String(actionHistory.total)}.`);
+  }
+  if (actionHistory && input.maxActionHistoryFailures !== undefined && actionHistory.failed > input.maxActionHistoryFailures) {
+    issues.push(`Expected at most ${String(input.maxActionHistoryFailures)} failed operator action(s), found ${String(actionHistory.failed)}.`);
+  }
+  for (const action of findMissing(historyActions, input.requiredHistoryActions)) {
+    issues.push(`Missing operator action history action: ${action}.`);
+  }
+  if (operationsRecord && input.requireOperationsRecordHealthy !== false && operationsRecord.status === "failed") {
+    issues.push("Expected operations record not to be failed.");
+  }
+  if (operationsRecord && input.requireOperationsRecordAudit && !operationsRecord.audit) {
+    issues.push("Expected operations record audit summary to be present.");
+  }
+  if (operationsRecord && input.minOperationsRecordHandoffs !== undefined && operationsRecord.handoffs.length < input.minOperationsRecordHandoffs) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordHandoffs)} operations-record handoff(s), found ${String(operationsRecord.handoffs.length)}.`);
+  }
+  if (operationsRecord && input.minOperationsRecordTasks !== undefined && (operationsRecord.tasks?.total ?? 0) < input.minOperationsRecordTasks) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordTasks)} operations-record task(s), found ${String(operationsRecord.tasks?.total ?? 0)}.`);
+  }
+  return {
+    actionHistoryFailed: actionHistory?.failed,
+    actionHistoryTotal: actionHistory?.total,
+    historyActions,
+    interventionActions,
+    interventions: opsRecovery?.interventions.total,
+    issues,
+    ok: issues.length === 0,
+    operationsRecordHandoffs: operationsRecord?.handoffs.length,
+    operationsRecordStatus: operationsRecord?.status,
+    operationsRecordTasks: operationsRecord?.tasks?.total,
+    opsRecoveryIssues: opsRecovery?.issues.length,
+    opsRecoveryStatus: opsRecovery?.status,
+    opsStatus: opsStatus?.status
+  };
+};
+var assertVoiceLiveOpsEvidence = (input = {}) => {
+  const assertion = evaluateVoiceLiveOpsEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice live-ops evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var createVoiceMemoryLiveOpsControlStore = () => {
   const states = new Map;
   return {

package/dist/vue/useVoiceLiveOps.d.ts

@@ -4,6 +4,6 @@ export declare function useVoiceLiveOps(options?: VoiceLiveOpsClientOptions): {
     isRunning: import("vue").Ref<boolean, boolean>;
     lastResult: import("vue").ShallowRef<VoiceLiveOpsActionResult | undefined, VoiceLiveOpsActionResult | undefined>;
     run: (input: import("..").VoiceLiveOpsActionInput) => Promise<VoiceLiveOpsActionResult | undefined>;
-    runningAction: import("vue").Ref<"assign" | "create-task" | "escalate" | "force-handoff" | "inject-instruction" | "operator-takeover" | "pause-assistant" | "resume-assistant" | "tag" | undefined, "assign" | "create-task" | "escalate" | "force-handoff" | "inject-instruction" | "operator-takeover" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
+    runningAction: import("vue").Ref<"escalate" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "operator-takeover" | "pause-assistant" | "resume-assistant" | "tag" | undefined, "escalate" | "assign" | "create-task" | "force-handoff" | "inject-instruction" | "operator-takeover" | "pause-assistant" | "resume-assistant" | "tag" | undefined>;
     updatedAt: import("vue").Ref<number | undefined, number | undefined>;
 };

package/package.json

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