@absolutejs/voice 0.0.22-beta.461 → 0.0.22-beta.464

package/dist/mediaPipelineRoutes.d.ts

@@ -1,5 +1,5 @@
 import { Elysia } from "elysia";
-import { type MediaFrame, type MediaInterruptionReport, type MediaPipelineCalibrationInput, type MediaPipelineCalibrationReport, type MediaPipelineStatus, type MediaProcessorGraphReport, type MediaQualityReport, type MediaResamplingPlan, type MediaTransportReport, type MediaVadReport } from "@absolutejs/media";
+import { type MediaFrame, type MediaInterruptionReport, type MediaPipelineCalibrationIssue, type MediaPipelineCalibrationInput, type MediaPipelineCalibrationReport, type MediaPipelineStatus, type MediaProcessorGraphReport, type MediaProcessorGraphSummary, type MediaQualityReport, type MediaQualitySummary, type MediaResamplingPlan, type MediaTransportReport, type MediaTransportSummary, type MediaVadReport } from "@absolutejs/media";
 export type VoiceMediaPipelineReportOptions = MediaPipelineCalibrationInput & {
     frames?: readonly MediaFrame[];
     maxInterruptionLatencyMs?: number;
@@ -115,3 +115,57 @@ export declare const createVoiceMediaPipelineRoutes: (options?: VoiceMediaPipeli
     standaloneSchema: {};
     response: {};
 }>;
+export type VoiceMediaPipelineCalibrationSummary = {
+    assistantAudioFrames: number;
+    backpressureFrames: number;
+    firstAudioLatencyMs?: number;
+    inputAudioFrames: number;
+    interruptionFrames: number;
+    issueCodes: readonly string[];
+    jitterMs?: number;
+    resamplingRequired: boolean;
+    status: MediaPipelineStatus;
+    surface: string;
+    traceLinkedFrames: number;
+    turnCommitFrames: number;
+};
+export type VoiceMediaPipelineProofArtifactLinks = {
+    processorGraph?: string;
+    quality?: string;
+    transport?: string;
+};
+export type VoiceMediaPipelineProofSummary = {
+    artifacts?: VoiceMediaPipelineProofArtifactLinks;
+    calibration: VoiceMediaPipelineCalibrationSummary;
+    checkedAt: number;
+    frames: number;
+    interruption: {
+        interruptionFrames: number;
+        issueCodes: readonly string[];
+        latenciesMs: readonly number[];
+        status: MediaPipelineStatus;
+    };
+    issueCodes: readonly string[];
+    issues: readonly MediaPipelineCalibrationIssue[];
+    ok: boolean;
+    processorGraph?: MediaProcessorGraphSummary;
+    quality: MediaQualitySummary;
+    resampling?: {
+        ratio: number;
+        required: boolean;
+        status: MediaPipelineStatus;
+    };
+    sessionIds: readonly string[];
+    status: MediaPipelineStatus;
+    surface: string;
+    transport?: MediaTransportSummary;
+    vad: {
+        inputAudioFrames: number;
+        segmentCount: number;
+        status: MediaPipelineStatus;
+    };
+};
+export type VoiceMediaPipelineProofSummaryOptions = {
+    artifacts?: VoiceMediaPipelineProofArtifactLinks;
+};
+export declare const summarizeVoiceMediaPipelineReport: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineProofSummaryOptions) => VoiceMediaPipelineProofSummary;

package/dist/mediaPipelineSurfaces.d.ts

@@ -0,0 +1,48 @@
+import { type MediaProcessorGraphSummary, type MediaQualitySummary, type MediaTransportSummary } from "@absolutejs/media";
+import type { VoiceIncidentTimelineEvent } from "./incidentTimeline";
+import type { VoiceMediaPipelineReport } from "./mediaPipelineRoutes";
+import type { VoiceProductionReadinessCheck } from "./productionReadiness";
+export type VoiceMediaPipelineIssueSource = "calibration" | "interruption" | "processor-graph" | "quality" | "transport";
+export type VoiceMediaPipelineIssueEntry = {
+    code: string;
+    message: string;
+    severity: "error" | "warning";
+    source: VoiceMediaPipelineIssueSource;
+    surface: string;
+};
+export declare const extractVoiceMediaPipelineIssueEntries: (report: VoiceMediaPipelineReport) => readonly VoiceMediaPipelineIssueEntry[];
+export type VoiceMediaPipelineReadinessOptions = {
+    baseHref?: string;
+    label?: string;
+};
+export declare const buildVoiceMediaPipelineReadinessChecks: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineReadinessOptions) => readonly VoiceProductionReadinessCheck[];
+export type VoiceMediaPipelineIncidentOptions = {
+    baseHref?: string;
+    category?: VoiceIncidentTimelineEvent["category"];
+    now?: () => number;
+    source?: string;
+};
+export declare const buildVoiceMediaPipelineIncidentEvents: (report: VoiceMediaPipelineReport, options?: VoiceMediaPipelineIncidentOptions) => readonly VoiceIncidentTimelineEvent[];
+export type VoiceMediaPipelineArtifactKind = "processor-graph" | "quality" | "transport";
+export type VoiceMediaPipelineArtifactRecord = {
+    href?: string;
+    jsonPath: string;
+    kind: VoiceMediaPipelineArtifactKind;
+    markdownPath: string;
+    summary: MediaProcessorGraphSummary | MediaQualitySummary | MediaTransportSummary;
+};
+export type VoiceMediaPipelineArtifactWriteOptions = {
+    dir: string;
+    hrefBase?: string;
+    report: VoiceMediaPipelineReport;
+    slugPrefix?: string;
+};
+export type VoiceMediaPipelineArtifactWriteResult = {
+    artifacts: VoiceMediaPipelineArtifactRecord[];
+    hrefs: {
+        processorGraph?: string;
+        quality?: string;
+        transport?: string;
+    };
+};
+export declare const writeVoiceMediaPipelineArtifacts: (options: VoiceMediaPipelineArtifactWriteOptions) => Promise<VoiceMediaPipelineArtifactWriteResult>;

package/dist/productionReadiness.d.ts

@@ -15,6 +15,7 @@ import type { VoiceAuditEventStore, VoiceAuditEventType, VoiceAuditOutcome } fro
 import { type VoiceAuditSinkDeliveryStore } from "./auditSinks";
 import type { VoiceProviderContractMatrixReport, VoiceProviderStackCapabilityGapReport } from "./providerStackRecommendations";
 import { type VoiceProviderSloReport, type VoiceProviderSloReportOptions } from "./providerSlo";
+import { type VoiceSessionObservabilityEvidenceInput, type VoiceSessionObservabilityReport } from "./sessionObservability";
 import type { VoiceProviderOrchestrationReport } from "./providerOrchestration";
 import type { VoiceCampaignReadinessProofReport } from "./campaign";
 import { type VoiceOpsRecoveryReport } from "./opsRecovery";
@@ -214,6 +215,7 @@ export type VoiceProductionReadinessReport = {
         resilience?: string;
         sessions?: string;
         sloReadinessThresholds?: string;
+        sessionObservability?: string;
         traceDeliveries?: string;
     };
     profile?: VoiceProductionReadinessProfileExplanation;
@@ -418,6 +420,13 @@ export type VoiceProductionReadinessReport = {
             status: VoiceProductionReadinessStatus;
             total: number;
         };
+        sessionObservability?: {
+            failed: number;
+            passed: number;
+            status: VoiceProductionReadinessStatus;
+            total: number;
+            warnings: number;
+        };
         quality: {
             status: "fail" | "pass";
         };
@@ -677,6 +686,14 @@ export type VoiceProductionReadinessRoutesOptions = {
     store: VoiceTraceEventStore;
     sttProviders?: readonly string[];
     title?: string;
+    sessionObservability?: false | VoiceSessionObservabilityReport | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceSessionObservabilityReport> | VoiceSessionObservabilityReport);
+    sessionObservabilityEvidence?: false | VoiceSessionObservabilityEvidenceInput | ((input: {
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<VoiceSessionObservabilityEvidenceInput> | VoiceSessionObservabilityEvidenceInput);
     traceDeliveries?: false | VoiceProductionReadinessTraceDeliveryOptions;
     ttsProviders?: readonly string[];
     traceMaxAgeMs?: number;

package/dist/proofTrends.d.ts

@@ -237,14 +237,28 @@ export type VoiceRealCallProfileTraceCollector<TEvent extends StoredVoiceTraceEv
     listEvidence: (options?: VoiceRealCallProfileTraceCollectorEvidenceOptions) => Promise<VoiceProofTrendRealCallProfileEvidence[]>;
 };
 export type VoiceRealCallEvidenceRuntimeSourceOptions = {
+    browserEvidence?: VoiceRealCallEvidenceRuntimeSurfaceEvidenceSource;
     existingEvidenceLimit?: number;
     evidenceStore: VoiceRealCallProfileEvidenceStore;
     history?: Omit<VoiceRealCallProfileHistoryOptions, "evidence">;
+    phoneEvidence?: VoiceRealCallEvidenceRuntimeSurfaceEvidenceSource;
+    providerRoleEvidence?: VoiceRealCallEvidenceRuntimeProviderRoleEvidenceSource;
     reconnectEvidence?: VoiceReconnectRealCallProfileEvidenceOptions;
     reconnectReports?: ((options: VoiceRealCallEvidenceRuntimeCollectOptions) => Promise<VoiceReconnectProofReport | VoiceReconnectContractReport | readonly (VoiceReconnectProofReport | VoiceReconnectContractReport)[] | undefined> | VoiceReconnectProofReport | VoiceReconnectContractReport | readonly (VoiceReconnectProofReport | VoiceReconnectContractReport)[] | undefined) | VoiceReconnectProofReport | VoiceReconnectContractReport | readonly (VoiceReconnectProofReport | VoiceReconnectContractReport)[];
     traceEvidence?: VoiceRealCallProfileTraceCollectorEvidenceOptions;
     traceStore?: VoiceTraceEventStore;
 };
+export type VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions = Omit<VoiceProofTrendRealCallProfileEvidence, "profileId" | "providers" | "sessionId" | "surfaces"> & {
+    profileId?: string;
+    providers?: readonly VoiceProofTrendProviderSummary[];
+    sessionId?: string;
+    surfaces?: readonly string[];
+};
+export type VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions = Omit<VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions, "providers"> & {
+    providers: readonly VoiceProofTrendProviderSummary[];
+};
+export type VoiceRealCallEvidenceRuntimeSurfaceEvidenceSource = VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions[] | ((options: VoiceRealCallEvidenceRuntimeCollectOptions) => Promise<VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions[] | undefined> | VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions[] | undefined);
+export type VoiceRealCallEvidenceRuntimeProviderRoleEvidenceSource = VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions[] | ((options: VoiceRealCallEvidenceRuntimeCollectOptions) => Promise<VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions[] | undefined> | VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions[] | undefined);
 export type VoiceRealCallEvidenceRuntimeOptions = VoiceRealCallEvidenceRuntimeSourceOptions & {
     dedupe?: boolean;
     now?: () => Date;
@@ -764,6 +778,17 @@ export declare const loadVoiceRealCallProfileEvidenceFromTraceStore: (options: V
 export declare const loadVoiceRealCallProfileEvidenceFromStore: (options: VoiceRealCallProfileEvidenceListOptions & {
     store: VoiceRealCallProfileEvidenceStore;
 }) => Promise<VoiceRealCallProfileEvidenceRecord[]>;
+export declare const buildVoiceRealCallProfileEvidenceFromRuntimeSurface: (input: VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeSurfaceEvidenceOptions[], options: {
+    defaultProfileId: string;
+    defaultSessionPrefix: string;
+    defaultSurfaces: readonly string[];
+    now?: () => Date;
+}) => VoiceProofTrendRealCallProfileEvidence[];
+export declare const buildVoiceRealCallProfileEvidenceFromRuntimeProviderRoles: (input: VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions | readonly VoiceRealCallEvidenceRuntimeProviderRoleEvidenceOptions[], options?: {
+    defaultProfileId?: string;
+    defaultSessionPrefix?: string;
+    now?: () => Date;
+}) => VoiceProofTrendRealCallProfileEvidence[];
 export declare const createVoiceRealCallEvidenceRuntime: (options: VoiceRealCallEvidenceRuntimeOptions) => VoiceRealCallEvidenceRuntime;
 export declare const buildVoiceRealCallEvidenceRuntimeReadinessCheck: (report: VoiceRealCallEvidenceRuntimeReport, options?: VoiceRealCallEvidenceRuntimeReadinessCheckOptions) => VoiceProductionReadinessCheck;
 export declare const createVoiceRealCallEvidenceRuntimeWorker: (options: VoiceRealCallEvidenceRuntimeWorkerOptions) => VoiceRealCallEvidenceRuntimeWorker;

package/dist/react/index.js

@@ -3769,7 +3769,38 @@ var resolveRealCallEvidenceRuntimeReconnectReports = async (reports, options) =>
   }
   return Array.isArray(resolved) ? resolved : [resolved];
 };
+var resolveRealCallEvidenceRuntimeSurfaceEvidence = async (source, options) => {
+  const resolved = typeof source === "function" ? await source(options) : source;
+  if (!resolved) {
+    return [];
+  }
+  return Array.isArray(resolved) ? [...resolved] : [resolved];
+};
+var createRealCallEvidenceRuntimeSessionId = (prefix, generatedAt) => `${prefix}-${Date.parse(generatedAt) || Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+var buildVoiceRealCallProfileEvidenceFromRuntimeSurface = (input, options) => {
+  const evidence = Array.isArray(input) ? input : [input];
+  return evidence.map((item) => {
+    const generatedAt = item.generatedAt ?? (options.now ?? (() => new Date))().toISOString();
+    return {
+      ...item,
+      generatedAt,
+      profileId: item.profileId ?? options.defaultProfileId,
+      providers: item.providers ? [...item.providers] : undefined,
+      sessionId: item.sessionId ?? createRealCallEvidenceRuntimeSessionId(options.defaultSessionPrefix, generatedAt),
+      surfaces: [
+        ...new Set([...item.surfaces ?? [], ...options.defaultSurfaces])
+      ].sort()
+    };
+  });
+};
+var buildVoiceRealCallProfileEvidenceFromRuntimeProviderRoles = (input, options = {}) => buildVoiceRealCallProfileEvidenceFromRuntimeSurface(input, {
+  defaultProfileId: options.defaultProfileId ?? "provider-role-evidence",
+  defaultSessionPrefix: options.defaultSessionPrefix ?? "provider-role-evidence",
+  defaultSurfaces: ["provider-path"],
+  now: options.now
+});
 var mergeRealCallEvidenceRuntimeOptions = (base, override = {}) => ({
+  browserEvidence: override.browserEvidence ?? base.browserEvidence,
   dedupe: override.dedupe ?? base.dedupe,
   evidenceStore: override.evidenceStore ?? base.evidenceStore,
   existingEvidenceLimit: override.existingEvidenceLimit ?? base.existingEvidenceLimit,
@@ -3778,6 +3809,8 @@ var mergeRealCallEvidenceRuntimeOptions = (base, override = {}) => ({
     ...override.history ?? {}
   },
   now: override.now ?? base.now,
+  phoneEvidence: override.phoneEvidence ?? base.phoneEvidence,
+  providerRoleEvidence: override.providerRoleEvidence ?? base.providerRoleEvidence,
   reconnectEvidence: {
     ...base.reconnectEvidence ?? {},
     ...override.reconnectEvidence ?? {}
@@ -3826,6 +3859,30 @@ var buildRealCallEvidenceRuntimeReport = async (options, input = {}) => {
 };
 var collectVoiceRealCallEvidenceRuntimeEvidence = async (options) => {
   const evidence = [];
+  const browserEvidence = await resolveRealCallEvidenceRuntimeSurfaceEvidence(options.browserEvidence, options);
+  if (browserEvidence.length > 0) {
+    evidence.push(...buildVoiceRealCallProfileEvidenceFromRuntimeSurface(browserEvidence, {
+      defaultProfileId: "browser-call",
+      defaultSessionPrefix: "browser-call",
+      defaultSurfaces: ["browser"],
+      now: options.now
+    }));
+  }
+  const phoneEvidence = await resolveRealCallEvidenceRuntimeSurfaceEvidence(options.phoneEvidence, options);
+  if (phoneEvidence.length > 0) {
+    evidence.push(...buildVoiceRealCallProfileEvidenceFromRuntimeSurface(phoneEvidence, {
+      defaultProfileId: "phone-agent",
+      defaultSessionPrefix: "phone-agent",
+      defaultSurfaces: ["phone", "telephony"],
+      now: options.now
+    }));
+  }
+  const providerRoleEvidence = await resolveRealCallEvidenceRuntimeSurfaceEvidence(options.providerRoleEvidence, options);
+  if (providerRoleEvidence.length > 0) {
+    evidence.push(...buildVoiceRealCallProfileEvidenceFromRuntimeProviderRoles(providerRoleEvidence, {
+      now: options.now
+    }));
+  }
   if (options.traceStore) {
     evidence.push(...buildVoiceRealCallProfileEvidenceFromTraceEvents(await options.traceStore.list({
       limit: options.traceEvidence?.limit ?? 5000
@@ -11030,6 +11087,8 @@ var serverMessageToAction = (message) => {
 };
 
 // node_modules/@absolutejs/media/dist/index.js
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
 var formatLabel = (format) => `${format.container}/${format.encoding}/${String(format.sampleRateHz)}hz/${String(format.channels)}ch`;
 var formatMatches = (actual, expected) => actual.container === expected.container && actual.encoding === expected.encoding && actual.sampleRateHz === expected.sampleRateHz && actual.channels === expected.channels;
 var pushIssue = (issues, severity, code, message) => {
@@ -11690,6 +11749,269 @@ var buildMediaPipelineCalibrationReport = (input = {}) => {
     turnCommitFrames: turnCommitFrames.length
   };
 };
+var DEFAULT_METADATA_DENY = [
+  "audioPayload",
+  "auth",
+  "authorization",
+  "cookie",
+  "email",
+  "phone",
+  "phoneNumber",
+  "rawPayload",
+  "secret",
+  "token",
+  "transcript",
+  "utterance"
+];
+var DEFAULT_TRUNCATE = 8;
+var issueCodes = (issues) => Array.from(new Set(issues.map((issue) => issue.code)));
+var lastEventKind = (events) => events[events.length - 1]?.kind;
+var formatOptionalMs = (value) => value === undefined ? "n/a" : `${String(Math.round(value))}ms`;
+var formatRatio = (value) => `${(value * 100).toFixed(1)}%`;
+var escapeMarkdownCell = (value) => value.replace(/\|/g, "\\|").replace(/\n/g, " ");
+var renderIssuesTable = (issues) => {
+  if (issues.length === 0) {
+    return `- No issues.
+`;
+  }
+  const rows = issues.map((issue) => `| ${issue.severity} | ${escapeMarkdownCell(issue.code)} | ${escapeMarkdownCell(issue.message)} |`).join(`
+`);
+  return `| Severity | Code | Message |
+| --- | --- | --- |
+${rows}
+`;
+};
+var summarizeMediaQualityReport = (report) => ({
+  backpressureEvents: report.backpressureEvents,
+  description: `${report.totalFrames} frame(s), ${report.gapCount} gap(s), speech ${formatRatio(report.speechRatio)}, status ${report.status}.`,
+  driftMs: report.timestampDriftMs,
+  frameCount: report.totalFrames,
+  gapCount: report.gapCount,
+  issueCodes: issueCodes(report.issues),
+  issueCount: report.issues.length,
+  jitterMs: report.jitterMs,
+  silenceRatio: report.silenceRatio,
+  speechRatio: report.speechRatio,
+  status: report.status
+});
+var summarizeMediaTransportReport = (report) => ({
+  backpressureEvents: report.backpressureEvents,
+  description: `${report.name}: ${report.state}, in ${report.inputFrames}, out ${report.outputFrames}, backpressure ${report.backpressureEvents}.`,
+  errors: report.events.filter((event) => event.kind === "error").length,
+  inputFrames: report.inputFrames,
+  lastEventKind: lastEventKind(report.events),
+  name: report.name,
+  outputFrames: report.outputFrames,
+  state: report.state,
+  status: report.status
+});
+var summarizeMediaProcessorGraphReport = (report) => {
+  const errorIssueCodes = Array.from(new Set(report.errors.map((event) => event.kind)));
+  return {
+    backpressureEvents: report.backpressure.events.length,
+    description: `${report.name}: ${report.state}, ${report.nodes.length} node(s), in ${report.inputFrames}, out ${report.emittedFrames}, dropped ${report.droppedFrames}.`,
+    droppedFrames: report.droppedFrames,
+    edgeCount: report.edges.length,
+    edgeEventCount: report.edgeEvents.length,
+    emittedFrames: report.emittedFrames,
+    errorCount: report.errors.length,
+    inputFrames: report.inputFrames,
+    issueCodes: errorIssueCodes,
+    lifecycleEventCount: report.lifecycleEvents.length,
+    name: report.name,
+    nodeCount: report.nodes.length,
+    state: report.state,
+    status: report.status,
+    timingMaxMs: report.timing.maxNodeMs
+  };
+};
+var renderMediaQualityMarkdown = (report, options = {}) => {
+  const title = options.title ?? "Media Quality Report";
+  const lines = [
+    `# ${title}`,
+    "",
+    `Status: **${report.status}**`,
+    "",
+    "| Metric | Value |",
+    "| --- | ---: |",
+    `| Total frames | ${report.totalFrames} |`,
+    `| Input audio | ${report.inputAudioFrames} |`,
+    `| Assistant audio | ${report.assistantAudioFrames} |`,
+    `| Gaps | ${report.gapCount} |`,
+    `| Jitter | ${formatOptionalMs(report.jitterMs)} |`,
+    `| Timestamp drift | ${formatOptionalMs(report.timestampDriftMs)} |`,
+    `| Speech ratio | ${formatRatio(report.speechRatio)} |`,
+    `| Silence ratio | ${formatRatio(report.silenceRatio)} |`,
+    `| Backpressure events | ${report.backpressureEvents} |`,
+    "",
+    "## Issues",
+    "",
+    renderIssuesTable(report.issues).trimEnd()
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var renderMediaTransportMarkdown = (report, options = {}) => {
+  const title = options.title ?? `Media Transport: ${report.name}`;
+  const limit = options.redact?.truncateArraysAt ?? DEFAULT_TRUNCATE;
+  const events = report.events.slice(-limit);
+  const eventRows = events.length === 0 ? "- No transport events recorded." : ["| At | Kind | State | Buffered | Error |", "| --- | --- | --- | ---: | --- |"].concat(events.map((event) => `| ${event.at} | ${event.kind} | ${event.state} | ${event.bufferedFrames ?? ""} | ${escapeMarkdownCell(event.error ?? "")} |`)).join(`
+`);
+  const lines = [
+    `# ${title}`,
+    "",
+    `Status: **${report.status}** \xB7 State: **${report.state}**`,
+    "",
+    "| Metric | Value |",
+    "| --- | ---: |",
+    `| Input frames | ${report.inputFrames} |`,
+    `| Output frames | ${report.outputFrames} |`,
+    `| Backpressure events | ${report.backpressureEvents} |`,
+    `| Connected | ${report.connected ? "yes" : "no"} |`,
+    `| Closed | ${report.closed ? "yes" : "no"} |`,
+    `| Failed | ${report.failed ? "yes" : "no"} |`,
+    "",
+    `## Last ${events.length} event(s)`,
+    "",
+    eventRows
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var renderMediaProcessorGraphMarkdown = (report, options = {}) => {
+  const title = options.title ?? `Media Processor Graph: ${report.name}`;
+  const limit = options.redact?.truncateArraysAt ?? DEFAULT_TRUNCATE;
+  const nodeRows = report.nodes.map((node) => `| ${escapeMarkdownCell(node.name)} | ${node.kind} | ${node.status} | ${node.inputFrames} | ${node.emittedFrames} | ${node.droppedFrames} | ${node.errors.length} |`).join(`
+`);
+  const edgeRows = report.edges.slice(0, limit).map((edge) => `| ${escapeMarkdownCell(edge.from)} | ${escapeMarkdownCell(edge.to)} | ${edge.status} | ${edge.emittedFrames} |`).join(`
+`);
+  const issues = report.errors.map((event) => ({
+    code: event.kind,
+    message: event.error ?? `Processor graph ${event.kind} (state ${event.state}).`,
+    severity: "error"
+  }));
+  const lines = [
+    `# ${title}`,
+    "",
+    `Status: **${report.status}** \xB7 State: **${report.state}**`,
+    "",
+    "| Metric | Value |",
+    "| --- | ---: |",
+    `| Nodes | ${report.nodes.length} |`,
+    `| Input frames | ${report.inputFrames} |`,
+    `| Emitted frames | ${report.emittedFrames} |`,
+    `| Dropped frames | ${report.droppedFrames} |`,
+    `| Lifecycle events | ${report.lifecycleEvents.length} |`,
+    `| Edge events | ${report.edgeEvents.length} |`,
+    `| Backpressure events | ${report.backpressure.events.length} |`,
+    `| Timing max | ${formatOptionalMs(report.timing.maxNodeMs)} |`,
+    `| Timing average | ${formatOptionalMs(report.timing.averageNodeMs)} |`,
+    "",
+    "## Nodes",
+    "",
+    nodeRows ? `| Node | Kind | Status | In | Out | Dropped | Errors |
+| --- | --- | --- | ---: | ---: | ---: | ---: |
+${nodeRows}` : "- No nodes.",
+    "",
+    `## Edges (showing up to ${limit})`,
+    "",
+    edgeRows ? `| From | To | Status | Frames |
+| --- | --- | --- | ---: |
+${edgeRows}` : "- No edges.",
+    "",
+    "## Errors",
+    "",
+    renderIssuesTable(issues).trimEnd()
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var truncateArrays = (value, limit, seen) => {
+  if (Array.isArray(value)) {
+    const head = value.slice(0, limit).map((entry) => truncateArrays(entry, limit, seen));
+    if (value.length > limit) {
+      return [...head, { truncated: value.length - limit }];
+    }
+    return head;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value))
+      return value;
+    seen.add(value);
+    const next = {};
+    for (const [key, entry] of Object.entries(value)) {
+      next[key] = truncateArrays(entry, limit, seen);
+    }
+    return next;
+  }
+  return value;
+};
+var applyRedaction = (value, options, seen) => {
+  const mode = options.mode ?? "omit";
+  const maskValue = options.maskValue ?? "[redacted]";
+  const allow = new Set(options.metadataAllow ?? []);
+  const deny = new Set(options.metadataDeny ?? DEFAULT_METADATA_DENY);
+  const walk = (input) => {
+    if (Array.isArray(input)) {
+      return input.map((entry) => walk(entry));
+    }
+    if (input && typeof input === "object") {
+      if (seen.has(input))
+        return input;
+      seen.add(input);
+      const next = {};
+      for (const [key, entry] of Object.entries(input)) {
+        if (allow.has(key)) {
+          next[key] = entry;
+          continue;
+        }
+        if (deny.has(key)) {
+          if (mode === "mask")
+            next[key] = maskValue;
+          continue;
+        }
+        next[key] = walk(entry);
+      }
+      return next;
+    }
+    return input;
+  };
+  return walk(value);
+};
+var redactMediaReport = (report, options = {}) => {
+  const limit = options.truncateArraysAt ?? DEFAULT_TRUNCATE;
+  const truncated = truncateArrays(report, limit, new WeakSet);
+  return applyRedaction(truncated, options, new WeakSet);
+};
+var buildArtifactPair = (report, summary, markdown, options) => {
+  const jsonValue = options.redact ? redactMediaReport(report, options.redact) : report;
+  return {
+    json: JSON.stringify(jsonValue, null, 2),
+    jsonValue,
+    markdown,
+    summary
+  };
+};
+var buildMediaQualityArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaQualityReport(report), renderMediaQualityMarkdown(report, options), options);
+var buildMediaTransportArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaTransportReport(report), renderMediaTransportMarkdown(report, options), options);
+var buildMediaProcessorGraphArtifact = (report, options = {}) => buildArtifactPair(report, summarizeMediaProcessorGraphReport(report), renderMediaProcessorGraphMarkdown(report, options), options);
+var writeMediaArtifact = async (input) => {
+  await mkdir(input.dir, { recursive: true });
+  const jsonPath = join(input.dir, `${input.slug}.json`);
+  const markdownPath = join(input.dir, `${input.slug}.md`);
+  await Promise.all([
+    writeFile(jsonPath, input.json, "utf8"),
+    writeFile(markdownPath, input.markdown, "utf8")
+  ]);
+  return {
+    jsonPath,
+    markdownPath,
+    summary: input.summary
+  };
+};
 
 // src/client/browserMedia.ts
 var DEFAULT_BROWSER_MEDIA_PATH = "/api/voice/browser-media";

package/dist/sessionObservability.d.ts

@@ -51,6 +51,45 @@ export type VoiceSessionObservabilityReport = {
     };
     turns: VoiceSessionObservabilityTurn[];
 };
+export type VoiceSessionObservabilityEvidenceStatus = "pass" | "warn" | "fail";
+export type VoiceSessionObservabilityEvidenceInput = {
+    requireHealthy?: boolean;
+    minStageCount?: number;
+    minTurns?: number;
+    minTurnWaterfalls?: number;
+    minProviderDecisions?: number;
+    minToolCalls?: number;
+    requireOperationsRecordLink?: boolean;
+    requireTraceTimelineLink?: boolean;
+    requireCallDebuggerLink?: boolean;
+    requireIncidentMarkdownLink?: boolean;
+    requireIncidentMarkdown?: boolean;
+    maxErrors?: number;
+    maxFallbacks?: number;
+    requireProviderRecoveryStatus?: VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"] | readonly VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"][];
+};
+export type VoiceSessionObservabilityEvidenceReport = {
+    checkedAt: number;
+    issues: string[];
+    ok: boolean;
+    status: VoiceSessionObservabilityEvidenceStatus;
+    summary: {
+        incidentMarkdownLength: number;
+        providerDecisions: number;
+        providerRecoveryStatus: VoiceOperationsRecord["providerDecisionSummary"]["recoveryStatus"];
+        reportStatus: VoiceSessionObservabilityStatus;
+        stages: number;
+        turns: number;
+        turnsWithWaterfalls: number;
+        toolCalls: number;
+        links: {
+            callDebugger: boolean;
+            incidentMarkdown: boolean;
+            operationsRecord: boolean;
+            traceTimeline: boolean;
+        };
+    };
+};
 export type VoiceSessionObservabilityReportOptions = Omit<VoiceOperationsRecordOptions, "sessionId"> & {
     callDebuggerHref?: false | string | ((sessionId: string) => string);
     customLinks?: readonly VoiceSessionObservabilityLink[];
@@ -74,6 +113,8 @@ export declare const renderVoiceSessionObservabilityMarkdown: (report: VoiceSess
 export declare const renderVoiceSessionObservabilityHTML: (report: VoiceSessionObservabilityReport, options?: {
     title?: string;
 }) => string;
+export declare const evaluateVoiceSessionObservabilityEvidence: (report: VoiceSessionObservabilityReport, input?: VoiceSessionObservabilityEvidenceInput) => VoiceSessionObservabilityEvidenceReport;
+export declare const assertVoiceSessionObservabilityEvidence: (report: VoiceSessionObservabilityReport, input?: VoiceSessionObservabilityEvidenceInput) => VoiceSessionObservabilityEvidenceReport;
 export declare const createVoiceSessionObservabilityRoutes: (options: VoiceSessionObservabilityRoutesOptions) => Elysia<"", {
     decorator: {};
     store: {};