@absolutejs/voice 0.0.22-beta.243 → 0.0.22-beta.245

package/README.md

@@ -37,6 +37,7 @@ These are the primitive-first paths a Vapi-style buyer usually needs. Each path
 | Phone voice assistant | `createVoicePhoneAgent(...)` | carrier matrix, setup instructions, phone smoke contract, production readiness, operations record | phone setup HTML/JSON, smoke HTML/JSON, framework status UI |
 | Multi-specialist support flow | `createVoiceAgentSquad(...)` | squad contract, handoff traces, context traces, operations record | Agent Squad status hooks/composables/services/widgets |
 | Business actions and tools | `createVoiceAgentTool(...)` plus agent tool runtime | tool contracts, audit events, integration events, outcome contracts | operations record, action center, contract routes |
+| Guardrails and policy checks | `createVoiceGuardrailPolicy(...)` plus `createVoiceGuardrailRoutes(...)` | blocking/warning decisions, redacted content, `assistant.guardrail` trace events | guardrail JSON/Markdown routes and operations record traces |
 | Provider routing and fallback | provider routers, health checks, simulation controls | provider contract matrix, provider-stage traces, latency SLO reports | provider contract hooks/composables/services/widgets |
 | Production operations | ops status, ops recovery, production readiness, delivery runtime | readiness gates, recovery report, incident Markdown, delivery queues | ops action center, delivery runtime UI, operations record |
 | Outbound campaigns | `createVoiceCampaignRoutes(...)` | recipient validation, consent/dedupe, carrier dry-run, campaign readiness | campaign routes and operations-record-linked attempt proof |
@@ -68,7 +69,7 @@ Use this checklist when a buyer asks, "How do I know this replaces a hosted voic
 | Can I prove provider fallback and latency? | provider contract matrix, provider status UI, `/turn-latency`, `/live-latency` | Provider choice, fallback behavior, server turn timing, browser p50/p95 timing |
 | Can operators intervene safely? | live-ops routes, action center, ops action audit routes, operations record | Pause/resume/takeover, injected instructions, operator action audit trail |
 | Can I run outbound campaigns? | `/voice/campaigns`, `/voice/campaigns/observability`, `/api/voice/campaigns/readiness-proof` | Recipient import evidence, consent/dedupe checks, scheduling policy, worker-safe attempts |
-| Can I handle post-call workflow? | reviews, tasks, integration events, outcome contracts, operations record | Summary/review artifacts, task creation, webhook/sink delivery, matched session proof |
+| Can I handle post-call workflow? | `createVoicePostCallAnalysisRoutes(...)`, reviews, tasks, integration events, outcome contracts, operations record | Extracted-field proof, task creation, webhook/sink delivery, matched session proof |
 | Can I keep data in my infrastructure? | `/data-control`, `/data-control/audit.md`, retention dry-run/apply routes | Customer-owned storage, redaction, audit export, guarded deletion, zero-retention planning |
 | Can I prove release readiness? | `/production-readiness`, `/ops-recovery`, delivery runtime, readiness profiles | Deploy gates for session health, audits, delivery queues, provider/campaign/phone proof |
 
@@ -82,6 +83,56 @@ For a demo, the fastest convincing path is:
 
 If those five surfaces are green and linked, the buyer can see the core difference from Vapi-style hosted orchestration: the operational proof lives inside the app, not in a vendor dashboard.
 
+## Post-Call Analysis Proof
+
+Use `createVoicePostCallAnalysisRoutes(...)` when the hosted-platform feature you need is call analysis plus follow-up proof. It validates that required extracted fields exist, expected ops tasks were created, integration/webhook events delivered, and the report links back to `/voice-operations/:sessionId`.
+
+```ts
+import { createVoicePostCallAnalysisRoutes } from '@absolutejs/voice';
+
+app.use(
+	createVoicePostCallAnalysisRoutes({
+		path: '/api/voice/post-call-analysis',
+		operationRecordBasePath: '/voice-operations/:sessionId',
+		reviews: runtime.reviews,
+		tasks: runtime.tasks,
+		integrationEvents: runtime.events,
+		source: ({ reviewId, sessionId }) => ({
+			reviewId,
+			sessionId,
+			// Use your own extractor output here, for example fields persisted from an LLM/tool result.
+			extractedFields: loadExtractedPostCallFields(reviewId ?? sessionId)
+		}),
+		fields: [
+			{ path: 'review.postCall.target', label: 'customer target' },
+			{ path: 'customerId' },
+			{ path: 'category' }
+		],
+		requiredTaskKinds: ['support-triage'],
+		requireDeliveredIntegrationEvent: true
+	})
+);
+```
+
+## Guardrails
+
+Use `createVoiceGuardrailRoutes(...)` when you need code-owned policy checks for what an agent may say, what tool payloads may contain, or which transcript content should warn/redact before downstream workflow. The primitive does not force a moderation vendor or hosted dashboard; it returns JSON/Markdown proof and can emit `assistant.guardrail` trace events.
+
+```ts
+import {
+	createVoiceGuardrailRoutes,
+	voiceGuardrailPolicyPresets
+} from '@absolutejs/voice';
+
+app.use(
+	createVoiceGuardrailRoutes({
+		path: '/api/voice/guardrails',
+		policies: [voiceGuardrailPolicyPresets.supportSafeDefaults],
+		trace: runtime.traces
+	})
+);
+```
+
 ## Use-Case Recipe: Support Triage
 
 Use this path when you want a Vapi-style support assistant that can answer web or phone calls, look up customer context, route billing issues to a specialist, create follow-up work, and leave one debuggable call record. It is a recipe over primitives, not a support app kit.

package/dist/guardrails.d.ts

@@ -0,0 +1,108 @@
+import { Elysia } from 'elysia';
+import type { VoiceTraceEventStore } from './trace';
+export type VoiceGuardrailStage = 'assistant-output' | 'handoff' | 'model-input' | 'tool-input' | 'tool-output' | 'transcript';
+export type VoiceGuardrailSeverity = 'block' | 'warn';
+export type VoiceGuardrailStatus = 'blocked' | 'pass' | 'warn';
+export type VoiceGuardrailRule = {
+    action?: VoiceGuardrailSeverity;
+    description?: string;
+    id: string;
+    label?: string;
+    match: RegExp | string | ((input: VoiceGuardrailEvaluationInput) => boolean | Promise<boolean>);
+    redactWith?: string;
+    stages?: VoiceGuardrailStage[];
+};
+export type VoiceGuardrailEvaluationInput = {
+    content?: unknown;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    turnId?: string;
+};
+export type VoiceGuardrailFinding = {
+    action: VoiceGuardrailSeverity;
+    description?: string;
+    label: string;
+    ruleId: string;
+    stage: VoiceGuardrailStage;
+};
+export type VoiceGuardrailDecision = {
+    allowed: boolean;
+    checkedAt: number;
+    content?: unknown;
+    findings: VoiceGuardrailFinding[];
+    redactedContent?: unknown;
+    sessionId?: string;
+    stage: VoiceGuardrailStage;
+    status: VoiceGuardrailStatus;
+    turnId?: string;
+};
+export type VoiceGuardrailPolicy = {
+    defaultAction?: VoiceGuardrailSeverity;
+    id: string;
+    label?: string;
+    rules: VoiceGuardrailRule[];
+};
+export type VoiceGuardrailReport = {
+    checkedAt: number;
+    decisions: VoiceGuardrailDecision[];
+    failed: number;
+    policies: Array<{
+        id: string;
+        label?: string;
+        rules: number;
+    }>;
+    status: 'fail' | 'pass' | 'warn';
+    summary: {
+        blocked: number;
+        passed: number;
+        warned: number;
+    };
+    total: number;
+};
+export type VoiceGuardrailRoutesOptions = {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    policies?: VoiceGuardrailPolicy[];
+    source?: ((input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision | VoiceGuardrailReport> | VoiceGuardrailDecision | VoiceGuardrailReport) | VoiceGuardrailDecision | VoiceGuardrailReport;
+    trace?: VoiceTraceEventStore;
+};
+export declare const evaluateVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy, input: VoiceGuardrailEvaluationInput) => Promise<VoiceGuardrailDecision>;
+export declare const buildVoiceGuardrailReport: (input?: {
+    decisions: VoiceGuardrailDecision[];
+    policies?: VoiceGuardrailPolicy[];
+}) => VoiceGuardrailReport;
+export declare const createVoiceGuardrailPolicy: (policy: VoiceGuardrailPolicy) => VoiceGuardrailPolicy;
+export declare const voiceGuardrailPolicyPresets: {
+    supportSafeDefaults: VoiceGuardrailPolicy;
+};
+export declare const renderVoiceGuardrailMarkdown: (report: VoiceGuardrailReport) => string;
+export declare const createVoiceGuardrailRoutes: (options?: VoiceGuardrailRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/index.d.ts

@@ -83,6 +83,8 @@ export { createVoiceCallReviewFromSession, recordVoiceRuntimeOps } from './runti
 export { createVoiceOpsRuntime } from './opsRuntime';
 export { resolveVoiceOpsPreset } from './opsPresets';
 export { resolveVoiceOutcomeRecipe } from './outcomeRecipes';
+export { buildVoicePostCallAnalysisReport, createVoicePostCallAnalysisRoutes, renderVoicePostCallAnalysisMarkdown } from './postCallAnalysis';
+export { buildVoiceGuardrailReport, createVoiceGuardrailPolicy, createVoiceGuardrailRoutes, evaluateVoiceGuardrailPolicy, renderVoiceGuardrailMarkdown, voiceGuardrailPolicyPresets } from './guardrails';
 export { createId, createVoiceSessionRecord } from './store';
 export { createVoiceSTTRoutingCorrectionHandler, resolveVoiceSTTRoutingStrategy } from './routing';
 export { applyRiskTieredPhraseHintCorrections, applyPhraseHintCorrections, createDomainLexicon, createDomainPhraseHints, createPhraseHintCorrectionHandler, createRiskyTurnCorrectionHandler } from './correction';
@@ -135,6 +137,8 @@ export type { VoiceToolContractCase, VoiceToolContractCaseReport, VoiceToolContr
 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';
+export type { VoicePostCallAnalysisFieldRequirement, VoicePostCallAnalysisFieldResult, VoicePostCallAnalysisIssue, VoicePostCallAnalysisIssueCode, VoicePostCallAnalysisOptions, VoicePostCallAnalysisReport, VoicePostCallAnalysisRoutesOptions, VoicePostCallAnalysisStatus } from './postCallAnalysis';
+export type { VoiceGuardrailDecision, VoiceGuardrailEvaluationInput, VoiceGuardrailFinding, VoiceGuardrailPolicy, VoiceGuardrailReport, VoiceGuardrailRoutesOptions, VoiceGuardrailRule, VoiceGuardrailSeverity, VoiceGuardrailStage, VoiceGuardrailStatus } from './guardrails';
 export type { VoiceCRMActivitySinkOptions, VoiceHubSpotTaskSinkOptions, VoiceHubSpotTaskUpdateSinkOptions, VoiceHelpdeskTicketSinkOptions, VoiceIntegrationHTTPSinkOptions, VoiceIntegrationSink, VoiceIntegrationSinkDeliveryResult, VoiceLinearIssueSinkOptions, VoiceLinearIssueUpdateSinkOptions, VoiceZendeskTicketSinkOptions, VoiceZendeskTicketUpdateSinkOptions } from './opsSinks';
 export type { VoiceOpsWebhookEnvelope, VoiceOpsWebhookEntity, VoiceOpsWebhookLinkResolver, VoiceOpsWebhookReceiverRoutesOptions, VoiceOpsWebhookSinkOptions, VoiceOpsWebhookVerificationResult } from './opsWebhook';
 export type { VoiceHandoffDelivery, VoiceHandoffDeliveryRecord, VoiceHandoffDeliveryRecordInput, VoiceHandoffFanoutResult, VoiceQueuedHandoffDeliveryOptions, VoiceTwilioRedirectHandoffAdapterOptions, VoiceWebhookHandoffAdapterOptions } from './handoff';

package/dist/index.js

@@ -28727,6 +28727,395 @@ var resolveVoiceOpsPreset = (name, overrides = {}) => {
     taskPolicies: mergePolicies(preset.taskPolicies, overrides.taskPolicies)
   };
 };
+// src/postCallAnalysis.ts
+import { Elysia as Elysia49 } from "elysia";
+var isStore = (value) => Boolean(value) && typeof value === "object" && value !== null && ("list" in value);
+var asArray = async (value) => Array.isArray(value) ? value : isStore(value) ? await value.list() : [];
+var getPathValue3 = (source, path) => {
+  const parts = path.split(".").filter(Boolean);
+  let current = source;
+  for (const part of parts) {
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+};
+var hasValue2 = (value) => {
+  if (value === undefined || value === null) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  return true;
+};
+var matchesReview = (reviewId, id) => Boolean(reviewId && id && (id === reviewId || id.startsWith(`${reviewId}:`)));
+var matchesSession = (sessionId, event) => {
+  const payloadSessionId = event.payload.sessionId;
+  return Boolean(sessionId && (event.id === sessionId || event.id.startsWith(`${sessionId}:`) || payloadSessionId === sessionId));
+};
+var matchesIntegrationEvent = (input) => {
+  const payloadReviewId = input.event.payload.reviewId;
+  return matchesReview(input.reviewId, input.event.id) || payloadReviewId === input.reviewId || matchesSession(input.sessionId, input.event);
+};
+var normalizeOperationRecordHref = (basePath, sessionId) => {
+  if (!basePath || !sessionId) {
+    return;
+  }
+  return basePath.includes(":sessionId") ? basePath.replace(":sessionId", encodeURIComponent(sessionId)) : `${basePath.replace(/\/$/, "")}/${encodeURIComponent(sessionId)}`;
+};
+var isPostCallAnalysisReport = (value) => ("status" in value) && ("summary" in value) && Array.isArray(value.issues);
+var buildVoicePostCallAnalysisReport = async (options = {}) => {
+  const reviews = await asArray(options.reviews);
+  const review = options.review ?? reviews.find((candidate) => options.reviewId ? candidate.id === options.reviewId : options.sessionId ? candidate.id.startsWith(`${options.sessionId}:`) : false);
+  const reviewId = options.reviewId ?? review?.id;
+  const sessionId = options.sessionId ?? (reviewId?.endsWith(":review") ? reviewId.slice(0, -":review".length) : undefined);
+  const allTasks = await asArray(options.tasks);
+  const tasks = allTasks.filter((task) => reviewId ? task.reviewId === reviewId || task.intakeId === reviewId || matchesReview(reviewId, task.id) : false);
+  const allIntegrationEvents = await asArray(options.integrationEvents);
+  const integrationEvents = allIntegrationEvents.filter((event) => matchesIntegrationEvent({ event, reviewId, sessionId }));
+  const fieldSource = {
+    extractedFields: options.extractedFields ?? {},
+    review
+  };
+  const fields = (options.fields ?? []).map((field) => {
+    const value = getPathValue3(fieldSource.extractedFields, field.path) ?? getPathValue3(fieldSource, field.path);
+    const required = field.required !== false;
+    return {
+      label: field.label ?? field.path,
+      ok: !required || hasValue2(value),
+      path: field.path,
+      required,
+      value
+    };
+  });
+  const requiredTaskKinds = options.requiredTaskKinds ?? [];
+  const missingTaskKinds = requiredTaskKinds.filter((kind) => !tasks.some((task) => task.kind === kind));
+  const deliveredIntegrationEvents = integrationEvents.filter((event) => event.deliveryStatus === "delivered").length;
+  const failedIntegrationEvents = integrationEvents.filter((event) => event.deliveryStatus === "failed").length;
+  const issues = [];
+  if (!review) {
+    issues.push({
+      code: "voice.post_call_analysis.review_missing",
+      label: "Review missing",
+      severity: "fail"
+    });
+  } else if (review.summary.pass === false) {
+    issues.push({
+      code: "voice.post_call_analysis.review_failed",
+      detail: review.errors.join("; ") || review.summary.outcome,
+      label: "Review failed",
+      severity: "fail"
+    });
+  }
+  for (const field of fields) {
+    if (field.required && !field.ok) {
+      issues.push({
+        code: "voice.post_call_analysis.required_field_missing",
+        detail: field.path,
+        label: `Missing ${field.label}`,
+        severity: "fail"
+      });
+    }
+  }
+  for (const kind of missingTaskKinds) {
+    issues.push({
+      code: "voice.post_call_analysis.required_task_missing",
+      detail: kind,
+      label: `Missing ${kind} task`,
+      severity: "fail"
+    });
+  }
+  if (options.requireDeliveredIntegrationEvent && deliveredIntegrationEvents === 0) {
+    issues.push({
+      code: "voice.post_call_analysis.integration_missing",
+      label: "Delivered integration event missing",
+      severity: "fail"
+    });
+  }
+  if (failedIntegrationEvents > 0) {
+    issues.push({
+      code: "voice.post_call_analysis.integration_failed",
+      detail: `${failedIntegrationEvents} failed integration event(s)`,
+      label: "Integration delivery failed",
+      severity: "warn"
+    });
+  }
+  const status = issues.some((issue) => issue.severity === "fail") ? "fail" : issues.length > 0 ? "warn" : "pass";
+  return {
+    checkedAt: options.at ?? Date.now(),
+    fields,
+    integrationEvents,
+    issues,
+    operationRecordHref: normalizeOperationRecordHref(options.operationRecordBasePath, sessionId),
+    review,
+    reviewId,
+    sessionId,
+    status,
+    summary: {
+      deliveredIntegrationEvents,
+      failedIntegrationEvents,
+      fields: fields.length,
+      missingRequiredFields: fields.filter((field) => field.required && !field.ok).length,
+      missingRequiredTasks: missingTaskKinds.length,
+      requiredFields: fields.filter((field) => field.required).length,
+      requiredTaskKinds: requiredTaskKinds.length,
+      tasks: tasks.length
+    },
+    tasks
+  };
+};
+var renderVoicePostCallAnalysisMarkdown = (report) => {
+  const lines = [
+    "# Voice Post-Call Analysis",
+    "",
+    `Status: ${report.status}`,
+    `Checked: ${new Date(report.checkedAt).toISOString()}`,
+    report.reviewId ? `Review: ${report.reviewId}` : undefined,
+    report.sessionId ? `Session: ${report.sessionId}` : undefined,
+    report.operationRecordHref ? `Operations record: ${report.operationRecordHref}` : undefined,
+    "",
+    "## Summary",
+    `- Fields: ${report.summary.fields}`,
+    `- Missing required fields: ${report.summary.missingRequiredFields}`,
+    `- Tasks: ${report.summary.tasks}`,
+    `- Missing required tasks: ${report.summary.missingRequiredTasks}`,
+    `- Delivered integration events: ${report.summary.deliveredIntegrationEvents}`,
+    `- Failed integration events: ${report.summary.failedIntegrationEvents}`,
+    "",
+    "## Issues",
+    ...report.issues.length ? report.issues.map((issue) => `- ${issue.severity}: ${issue.code} - ${issue.label}${issue.detail ? ` (${issue.detail})` : ""}`) : ["- none"]
+  ].filter((line) => line !== undefined);
+  return `${lines.join(`
+`)}
+`;
+};
+var resolvePostCallAnalysisReport = async (options, input) => {
+  const source = options.source === undefined ? options : typeof options.source === "function" ? await options.source(input) : options.source;
+  const merged = {
+    ...options,
+    ...source,
+    reviewId: input.reviewId ?? source.reviewId ?? options.reviewId,
+    sessionId: input.sessionId ?? source.sessionId ?? options.sessionId
+  };
+  return isPostCallAnalysisReport(merged) ? merged : buildVoicePostCallAnalysisReport(merged);
+};
+var createVoicePostCallAnalysisRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice/post-call-analysis";
+  const routes = new Elysia49({
+    name: options.name ?? "absolutejs-voice-post-call-analysis"
+  });
+  routes.get(path, async ({ query }) => {
+    const report = await resolvePostCallAnalysisReport(options, {
+      reviewId: typeof query.reviewId === "string" ? query.reviewId : undefined,
+      sessionId: typeof query.sessionId === "string" ? query.sessionId : undefined
+    });
+    return Response.json(report, { headers: options.headers });
+  });
+  routes.get(`${path}.md`, async ({ query }) => {
+    const report = await resolvePostCallAnalysisReport(options, {
+      reviewId: typeof query.reviewId === "string" ? query.reviewId : undefined,
+      sessionId: typeof query.sessionId === "string" ? query.sessionId : undefined
+    });
+    return new Response(renderVoicePostCallAnalysisMarkdown(report), {
+      headers: {
+        "content-type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  return routes;
+};
+// src/guardrails.ts
+import { Elysia as Elysia50 } from "elysia";
+var stringifyContent = (value) => typeof value === "string" ? value : JSON.stringify(value) ?? "";
+var appliesToStage = (rule, stage) => !rule.stages || rule.stages.length === 0 || rule.stages.includes(stage);
+var matchesRule = async (rule, input) => {
+  if (!appliesToStage(rule, input.stage)) {
+    return false;
+  }
+  if (typeof rule.match === "function") {
+    return rule.match(input);
+  }
+  const content = stringifyContent(input.content);
+  return typeof rule.match === "string" ? content.toLowerCase().includes(rule.match.toLowerCase()) : rule.match.test(content);
+};
+var applyRedactions = (content, rules, findings) => {
+  if (typeof content !== "string") {
+    return content;
+  }
+  return findings.reduce((value, finding) => {
+    const rule = rules.find((candidate) => candidate.id === finding.ruleId);
+    if (!rule || !rule.redactWith) {
+      return value;
+    }
+    if (typeof rule.match === "string") {
+      return value.replaceAll(rule.match, rule.redactWith);
+    }
+    if (rule.match instanceof RegExp) {
+      return value.replace(rule.match, rule.redactWith);
+    }
+    return value;
+  }, content);
+};
+var evaluateVoiceGuardrailPolicy = async (policy, input) => {
+  const findings = [];
+  for (const rule of policy.rules) {
+    if (!await matchesRule(rule, input)) {
+      continue;
+    }
+    findings.push({
+      action: rule.action ?? policy.defaultAction ?? "block",
+      description: rule.description,
+      label: rule.label ?? rule.id,
+      ruleId: rule.id,
+      stage: input.stage
+    });
+  }
+  const blocked = findings.some((finding) => finding.action === "block");
+  const status = blocked ? "blocked" : findings.length > 0 ? "warn" : "pass";
+  return {
+    allowed: !blocked,
+    checkedAt: Date.now(),
+    content: input.content,
+    findings,
+    redactedContent: applyRedactions(input.content, policy.rules, findings),
+    sessionId: input.sessionId,
+    stage: input.stage,
+    status,
+    turnId: input.turnId
+  };
+};
+var buildVoiceGuardrailReport = (input = { decisions: [] }) => {
+  const blocked = input.decisions.filter((decision) => decision.status === "blocked").length;
+  const warned = input.decisions.filter((decision) => decision.status === "warn").length;
+  const passed = input.decisions.filter((decision) => decision.status === "pass").length;
+  const status = blocked > 0 ? "fail" : warned > 0 ? "warn" : "pass";
+  return {
+    checkedAt: Date.now(),
+    decisions: input.decisions,
+    failed: blocked,
+    policies: (input.policies ?? []).map((policy) => ({
+      id: policy.id,
+      label: policy.label,
+      rules: policy.rules.length
+    })),
+    status,
+    summary: {
+      blocked,
+      passed,
+      warned
+    },
+    total: input.decisions.length
+  };
+};
+var createVoiceGuardrailPolicy = (policy) => policy;
+var voiceGuardrailPolicyPresets = {
+  supportSafeDefaults: createVoiceGuardrailPolicy({
+    id: "support-safe-defaults",
+    label: "Support safe defaults",
+    rules: [
+      {
+        description: "Blocks final legal, medical, or financial advice claims that should route to a human or qualified professional.",
+        id: "regulated-advice",
+        label: "Regulated advice",
+        match: /\b(legal advice|medical advice|financial advice|diagnose|prescribe|guaranteed refund|guaranteed approval)\b/i,
+        stages: ["assistant-output"]
+      },
+      {
+        description: "Warns when payment-card-like data appears in transcripts or tool payloads.",
+        action: "warn",
+        id: "payment-card-like-data",
+        label: "Payment card-like data",
+        match: /\b(?:\d[ -]*?){13,19}\b/,
+        redactWith: "[redacted-card]",
+        stages: ["transcript", "tool-input", "tool-output"]
+      }
+    ]
+  })
+};
+var renderVoiceGuardrailMarkdown = (report) => {
+  const lines = [
+    "# Voice Guardrail Report",
+    "",
+    `Status: ${report.status}`,
+    `Checked: ${new Date(report.checkedAt).toISOString()}`,
+    `Decisions: ${report.total}`,
+    `Blocked: ${report.summary.blocked}`,
+    `Warned: ${report.summary.warned}`,
+    "",
+    "## Decisions",
+    ...report.decisions.length > 0 ? report.decisions.map((decision) => `- ${decision.status}: ${decision.stage}${decision.sessionId ? ` session=${decision.sessionId}` : ""} findings=${decision.findings.length}`) : ["- none"]
+  ];
+  return `${lines.join(`
+`)}
+`;
+};
+var isGuardrailReport = (value) => ("decisions" in value) && ("summary" in value);
+var normalizeGuardrailRouteInput = async (request) => {
+  if (request.method === "POST") {
+    return await request.json().catch(() => ({}));
+  }
+  const url = new URL(request.url);
+  return {
+    content: url.searchParams.get("content") ?? "",
+    sessionId: url.searchParams.get("sessionId") ?? undefined,
+    stage: url.searchParams.get("stage") ?? "assistant-output",
+    turnId: url.searchParams.get("turnId") ?? undefined
+  };
+};
+var resolveGuardrailReport = async (options, input) => {
+  if (options.source !== undefined) {
+    const value = typeof options.source === "function" ? await options.source(input) : options.source;
+    return isGuardrailReport(value) ? value : buildVoiceGuardrailReport({ decisions: [value] });
+  }
+  const decisions = await Promise.all((options.policies ?? []).map((policy) => evaluateVoiceGuardrailPolicy(policy, input)));
+  return buildVoiceGuardrailReport({
+    decisions,
+    policies: options.policies
+  });
+};
+var createVoiceGuardrailRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice/guardrails";
+  const routes = new Elysia50({
+    name: options.name ?? "absolutejs-voice-guardrails"
+  });
+  routes.all(path, async ({ request }) => {
+    const input = await normalizeGuardrailRouteInput(request);
+    const report = await resolveGuardrailReport(options, input);
+    if (options.trace) {
+      await Promise.all(report.decisions.map((decision) => options.trace.append({
+        at: decision.checkedAt,
+        payload: {
+          allowed: decision.allowed,
+          findings: decision.findings,
+          stage: decision.stage,
+          status: decision.status
+        },
+        sessionId: decision.sessionId ?? "guardrail-check",
+        turnId: decision.turnId,
+        type: "assistant.guardrail"
+      })));
+    }
+    return Response.json(report, { headers: options.headers });
+  });
+  routes.all(`${path}.md`, async ({ request }) => {
+    const input = await normalizeGuardrailRouteInput(request);
+    const report = await resolveGuardrailReport(options, input);
+    return new Response(renderVoiceGuardrailMarkdown(report), {
+      headers: {
+        "content-type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  return routes;
+};
 // src/correction.ts
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var buildAliasMatcher = (alias) => new RegExp(`(?<![\\p{L}\\p{N}'])${escapeRegExp(alias)}(?![\\p{L}\\p{N}'])`, "giu");
@@ -29119,6 +29508,7 @@ export {
   voiceTelephonyOutcomeToRouteResult,
   voiceObservabilityExportSchemaVersion,
   voiceObservabilityExportSchemaId,
+  voiceGuardrailPolicyPresets,
   voiceComplianceRedactionDefaults,
   voice,
   verifyVoiceTwilioWebhookSignature,
@@ -29219,6 +29609,7 @@ export {
   renderVoiceProviderContractMatrixHTML,
   renderVoiceProviderCapabilityHTML,
   renderVoiceProductionReadinessHTML,
+  renderVoicePostCallAnalysisMarkdown,
   renderVoicePhoneAgentProductionSmokeHTML,
   renderVoiceOutcomeContractHTML,
   renderVoiceOpsStatusHTML,
@@ -29233,6 +29624,7 @@ export {
   renderVoiceLiveLatencyHTML,
   renderVoiceLatencySLOMarkdown,
   renderVoiceHandoffHealthHTML,
+  renderVoiceGuardrailMarkdown,
   renderVoiceEvalHTML,
   renderVoiceEvalBaselineHTML,
   renderVoiceDemoReadyHTML,
@@ -29292,6 +29684,7 @@ export {
   evaluateVoiceTelephonyContract,
   evaluateVoiceQuality,
   evaluateVoiceProviderStackGaps,
+  evaluateVoiceGuardrailPolicy,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
   deliverVoiceObservabilityExport,
@@ -29414,6 +29807,7 @@ export {
   createVoicePostgresCampaignStore,
   createVoicePostgresAuditSinkDeliveryStore,
   createVoicePostgresAuditEventStore,
+  createVoicePostCallAnalysisRoutes,
   createVoicePlivoCampaignDialer,
   createVoicePlatformCoverageRoutes,
   createVoicePhoneAgentProductionSmokeRoutes,
@@ -29470,6 +29864,8 @@ export {
   createVoiceHandoffDeliveryWorkerLoop,
   createVoiceHandoffDeliveryWorker,
   createVoiceHandoffDeliveryRecord,
+  createVoiceGuardrailRoutes,
+  createVoiceGuardrailPolicy,
   createVoiceFileTraceSinkDeliveryStore,
   createVoiceFileTraceEventStore,
   createVoiceFileTaskStore,
@@ -29570,6 +29966,7 @@ export {
   buildVoiceProofTrendReport,
   buildVoiceProductionReadinessReport,
   buildVoiceProductionReadinessGate,
+  buildVoicePostCallAnalysisReport,
   buildVoicePlatformCoverageSummary,
   buildVoiceOpsTaskFromSLABreach,
   buildVoiceOpsTaskFromReview,
@@ -29585,6 +29982,7 @@ export {
   buildVoiceLiveOpsControlState,
   buildVoiceLatencySLOGate,
   buildVoiceIncidentBundle,
+  buildVoiceGuardrailReport,
   buildVoiceDiagnosticsMarkdown,
   buildVoiceDemoReadyReport,
   buildVoiceDeliverySinkReport,

package/dist/postCallAnalysis.d.ts

@@ -0,0 +1,98 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventStore, VoiceOpsTaskKind, VoiceOpsTaskStore } from './ops';
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from './testing/review';
+export type VoicePostCallAnalysisStatus = 'fail' | 'pass' | 'warn';
+export type VoicePostCallAnalysisFieldRequirement = {
+    label?: string;
+    path: string;
+    required?: boolean;
+};
+export type VoicePostCallAnalysisFieldResult = {
+    label: string;
+    ok: boolean;
+    path: string;
+    required: boolean;
+    value?: unknown;
+};
+export type VoicePostCallAnalysisIssueCode = 'voice.post_call_analysis.integration_failed' | 'voice.post_call_analysis.integration_missing' | 'voice.post_call_analysis.required_field_missing' | 'voice.post_call_analysis.required_task_missing' | 'voice.post_call_analysis.review_failed' | 'voice.post_call_analysis.review_missing';
+export type VoicePostCallAnalysisIssue = {
+    code: VoicePostCallAnalysisIssueCode;
+    detail?: string;
+    label: string;
+    severity: Exclude<VoicePostCallAnalysisStatus, 'pass'>;
+};
+export type VoicePostCallAnalysisReport = {
+    checkedAt: number;
+    fields: VoicePostCallAnalysisFieldResult[];
+    integrationEvents: StoredVoiceIntegrationEvent[];
+    issues: VoicePostCallAnalysisIssue[];
+    operationRecordHref?: string;
+    review?: StoredVoiceCallReviewArtifact;
+    reviewId?: string;
+    sessionId?: string;
+    status: VoicePostCallAnalysisStatus;
+    summary: {
+        deliveredIntegrationEvents: number;
+        failedIntegrationEvents: number;
+        fields: number;
+        missingRequiredFields: number;
+        missingRequiredTasks: number;
+        requiredFields: number;
+        requiredTaskKinds: number;
+        tasks: number;
+    };
+    tasks: StoredVoiceOpsTask[];
+};
+export type VoicePostCallAnalysisOptions = {
+    at?: number;
+    extractedFields?: Record<string, unknown>;
+    fields?: VoicePostCallAnalysisFieldRequirement[];
+    integrationEvents?: StoredVoiceIntegrationEvent[] | VoiceIntegrationEventStore;
+    operationRecordBasePath?: string;
+    requireDeliveredIntegrationEvent?: boolean;
+    requiredTaskKinds?: VoiceOpsTaskKind[];
+    review?: StoredVoiceCallReviewArtifact;
+    reviewId?: string;
+    reviews?: StoredVoiceCallReviewArtifact[] | VoiceCallReviewStore;
+    sessionId?: string;
+    tasks?: StoredVoiceOpsTask[] | VoiceOpsTaskStore;
+};
+export type VoicePostCallAnalysisRoutesOptions = VoicePostCallAnalysisOptions & {
+    headers?: HeadersInit;
+    name?: string;
+    path?: string;
+    source?: ((input: {
+        reviewId?: string;
+        sessionId?: string;
+    }) => Promise<VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport> | VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport) | VoicePostCallAnalysisOptions | VoicePostCallAnalysisReport;
+};
+export declare const buildVoicePostCallAnalysisReport: (options?: VoicePostCallAnalysisOptions) => Promise<VoicePostCallAnalysisReport>;
+export declare const renderVoicePostCallAnalysisMarkdown: (report: VoicePostCallAnalysisReport) => string;
+export declare const createVoicePostCallAnalysisRoutes: (options?: VoicePostCallAnalysisRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/package.json

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