agentic-qe 3.13.12 → 3.14.1

package/dist/validation/verification-reach.js

@@ -0,0 +1,187 @@
+/**
+ * Failure-mode verification reach contracts (#651).
+ *
+ * Quality evidence is useful only within the boundary it actually observed.
+ * This module keeps that boundary revision-bound and fail-closed: direct,
+ * executed, fresh evidence with the required oracle can cover a risk; partial,
+ * inferred, stale, unavailable, and wrong-target evidence remains visible but
+ * cannot silently produce a passing coverage verdict.
+ */
+import { createHash } from 'node:crypto';
+/** Create a manifest whose hash binds its target, risks, checks, and lifetime. */
+export function createVerificationReachManifest(input) {
+    validateManifestShape(input);
+    const manifest = structuredClone(input);
+    return {
+        ...manifest,
+        manifestHash: computeVerificationReachManifestHash(manifest),
+    };
+}
+/** Compute the canonical SHA-256 identity for all manifest content except the hash itself. */
+export function computeVerificationReachManifestHash(manifest) {
+    const { manifestHash: _ignored, ...content } = manifest;
+    return `sha256:${createHash('sha256').update(canonicalJson(content)).digest('hex')}`;
+}
+/** Bind a reach manifest to the exact artifact bytes submitted to the gate. */
+export function computeVerificationArtifactDigest(artifact) {
+    return `sha256:${createHash('sha256').update(artifact).digest('hex')}`;
+}
+/** Evaluate whether the declared evidence can directly observe every required failure mode. */
+export function evaluateVerificationReach(manifest, options = {}) {
+    validateManifestShape(manifest);
+    const expectedHash = computeVerificationReachManifestHash(manifest);
+    if (manifest.manifestHash !== expectedHash) {
+        throw new Error(`Verification reach manifestHash mismatch: expected ${expectedHash}`);
+    }
+    const now = options.now ?? new Date();
+    const evaluatedAt = now.toISOString();
+    const manifestExpired = manifest.expiresAt != null
+        && now.getTime() > parseTimestamp(manifest.expiresAt, 'expiresAt');
+    const risks = manifest.risks.map((requirement) => evaluateRisk(requirement, manifest, manifestExpired, now.getTime()));
+    return {
+        manifestId: manifest.id,
+        manifestHash: manifest.manifestHash,
+        systemUnderTest: manifest.systemUnderTest,
+        artifact: structuredClone(manifest.artifact),
+        coverageVerdict: aggregateVerdicts(risks.map((risk) => risk.verdict)),
+        risks,
+        evaluatedAt,
+    };
+}
+function evaluateRisk(requirement, manifest, manifestExpired, evaluatedAt) {
+    const direct = new Set();
+    const partial = new Set();
+    const failed = new Set();
+    const covered = new Set();
+    const limitations = new Set();
+    for (const check of requirement.checks) {
+        for (const limitation of check.limitations)
+            limitations.add(limitation);
+        if (!isUsableObservation(check, manifest, manifestExpired, evaluatedAt))
+            continue;
+        if (check.reach === 'partial') {
+            partial.add(check.checkId);
+            continue;
+        }
+        if (check.reach !== 'direct')
+            continue;
+        if (!requirement.requiredObservations.includes(check.channel))
+            continue;
+        if (check.oracleRef !== requirement.requiredOracle)
+            continue;
+        if (check.executionStatus === 'failed') {
+            failed.add(check.checkId);
+            continue;
+        }
+        if (check.executionStatus === 'passed') {
+            direct.add(check.checkId);
+            covered.add(check.channel);
+        }
+    }
+    const uncoveredObservations = requirement.requiredObservations.filter((channel) => !covered.has(channel));
+    const verdict = failed.size > 0
+        ? 'fail'
+        : uncoveredObservations.length === 0
+            ? 'pass'
+            : requirement.dispositionWhenUncovered;
+    return {
+        riskId: requirement.riskId,
+        failureMode: requirement.failureMode,
+        severity: requirement.severity,
+        verdict,
+        directCheckIds: [...direct],
+        partialCheckIds: [...partial],
+        failedCheckIds: [...failed],
+        uncoveredObservations,
+        limitations: [...limitations],
+        reason: buildRiskReason(verdict, failed, uncoveredObservations, manifestExpired),
+    };
+}
+function isUsableObservation(check, manifest, manifestExpired, evaluatedAt) {
+    if (manifestExpired)
+        return false;
+    if (!sameTarget(check.target, manifest.artifact))
+        return false;
+    if (check.evidenceClass !== 'EXECUTED')
+        return false;
+    if (check.executionStatus === 'not-run' || check.executionStatus === 'unavailable')
+        return false;
+    if (!check.observedAt)
+        return false;
+    const observedAt = parseTimestamp(check.observedAt, `check ${check.checkId} observedAt`);
+    const generatedAt = parseTimestamp(manifest.generatedAt, 'generatedAt');
+    if (observedAt < generatedAt)
+        return false;
+    if (observedAt > evaluatedAt)
+        return false;
+    if (manifest.expiresAt && observedAt > parseTimestamp(manifest.expiresAt, 'expiresAt'))
+        return false;
+    return true;
+}
+function sameTarget(actual, expected) {
+    return actual.revision === expected.revision
+        && actual.digest === expected.digest
+        && actual.environment === expected.environment;
+}
+function aggregateVerdicts(verdicts) {
+    if (verdicts.some((verdict) => verdict === 'fail'))
+        return 'fail';
+    if (verdicts.some((verdict) => verdict === 'human-review'))
+        return 'human-review';
+    if (verdicts.some((verdict) => verdict === 'inconclusive'))
+        return 'inconclusive';
+    return 'pass';
+}
+function buildRiskReason(verdict, failed, uncovered, manifestExpired) {
+    if (manifestExpired)
+        return `verification manifest expired; uncovered: ${uncovered.join(', ')}`;
+    if (failed.size > 0)
+        return `direct check failed: ${[...failed].join(', ')}`;
+    if (verdict === 'pass')
+        return 'all required observation channels have direct executed reach';
+    return `required reach is uncovered (${uncovered.join(', ')}); disposition: ${verdict}`;
+}
+function validateManifestShape(manifest) {
+    if (!manifest.id || !manifest.systemUnderTest) {
+        throw new Error('Verification reach manifest requires id and systemUnderTest');
+    }
+    if (!manifest.artifact.revision || !manifest.artifact.digest || !manifest.artifact.environment) {
+        throw new Error('Verification reach manifest artifact requires revision, digest, and environment');
+    }
+    parseTimestamp(manifest.generatedAt, 'generatedAt');
+    if (manifest.expiresAt)
+        parseTimestamp(manifest.expiresAt, 'expiresAt');
+    if (manifest.risks.length === 0) {
+        throw new Error('Verification reach manifest requires at least one failure mode');
+    }
+    const riskIds = new Set();
+    for (const risk of manifest.risks) {
+        if (riskIds.has(risk.riskId))
+            throw new Error(`Duplicate riskId: ${risk.riskId}`);
+        riskIds.add(risk.riskId);
+        if (!risk.riskId || !risk.failureMode || !risk.requiredOracle) {
+            throw new Error('Each failure mode requires riskId, failureMode, and requiredOracle');
+        }
+        if (risk.requiredObservations.length === 0) {
+            throw new Error(`Failure mode ${risk.riskId} requires at least one observation channel`);
+        }
+    }
+}
+function parseTimestamp(value, field) {
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp))
+        throw new Error(`Invalid ${field} timestamp: ${value}`);
+    return timestamp;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+        return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonicalJson(entry)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=verification-reach.js.map

package/dist/verification/adversarial-verify/calibrate.d.ts

@@ -7,11 +7,52 @@
  * — a deterministic stub (characterize the k-of-n aggregation) or a real LLM
  * (empirical false-kill on a labeled corpus).
  */
-import type { AdversarialVerifyOptions, Finding } from './types.js';
+import type { AdversarialVerifyOptions, Finding, FindingSeverity } from './types.js';
 export interface LabeledFinding {
     finding: Finding;
     /** Ground truth: is this a genuine, actionable problem? */
     isReal: boolean;
+    failureType?: string;
+    domain?: string;
+    expectedSeverity?: FindingSeverity;
+    source?: 'human' | 'oracle' | 'controlled-intervention';
+}
+export interface ConfidenceInterval {
+    low: number;
+    high: number;
+    level: 0.95;
+}
+export type QualificationDisposition = 'automate' | 'human-review' | 'abstain';
+export interface QualificationSlice {
+    key: string;
+    support: number;
+    precision: number;
+    recall: number;
+    falseKillRate: number;
+    falseKeepRate: number;
+    uncertainRate: number;
+    intervals: {
+        precision: ConfidenceInterval;
+        recall: ConfidenceInterval;
+        falseKillRate: ConfidenceInterval;
+        falseKeepRate: ConfidenceInterval;
+    };
+    disposition: QualificationDisposition;
+}
+export interface QualificationOptions {
+    minSupport?: number;
+    minRecall?: number;
+    minPrecision?: number;
+    maxFalseKillRate?: number;
+    maxFalseKeepRate?: number;
+    criticalSeverities?: FindingSeverity[];
+}
+export interface JudgeQualification {
+    status: 'qualified' | 'restricted' | 'unqualified';
+    automatedSlices: string[];
+    humanReviewSlices: string[];
+    abstainSlices: string[];
+    reasons: string[];
 }
 export interface CalibrationReport {
     total: number;
@@ -26,7 +67,10 @@ export interface CalibrationReport {
     correctConfirm: number;
     correctKill: number;
     uncertain: number;
+    slices: QualificationSlice[];
+    qualification: JudgeQualification;
 }
+export declare function qualifyJudge(slices: QualificationSlice[], criticalSliceKeys?: string[]): JudgeQualification;
 /** Run the verifier over a labeled set and report the confusion vs ground truth. */
-export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions): Promise<CalibrationReport>;
+export declare function calibrate(labeled: LabeledFinding[], opts: AdversarialVerifyOptions, qualificationOptions?: QualificationOptions): Promise<CalibrationReport>;
 //# sourceMappingURL=calibrate.d.ts.map

package/dist/verification/adversarial-verify/calibrate.js

@@ -1,11 +1,90 @@
 import { adversarialVerify } from './verify.js';
+const DEFAULT_QUALIFICATION = {
+    minSupport: 10,
+    minRecall: 0.8,
+    minPrecision: 0.8,
+    maxFalseKillRate: 0.1,
+    maxFalseKeepRate: 0.1,
+    criticalSeverities: ['critical', 'high'],
+};
+function wilson(successes, total) {
+    if (total === 0)
+        return { low: 0, high: 1, level: 0.95 };
+    const z = 1.959963984540054;
+    const p = successes / total;
+    const z2 = z * z;
+    const denominator = 1 + z2 / total;
+    const centre = (p + z2 / (2 * total)) / denominator;
+    const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * total)) / total) / denominator;
+    return { low: Math.max(0, centre - margin), high: Math.min(1, centre + margin), level: 0.95 };
+}
+function buildSlice(key, entries, policy) {
+    const real = entries.filter(entry => entry.label.isReal);
+    const falseEntries = entries.filter(entry => !entry.label.isReal);
+    const upheldReal = real.filter(entry => entry.verdict === 'upheld').length;
+    const upheldFalse = falseEntries.filter(entry => entry.verdict === 'upheld').length;
+    const falseKill = real.filter(entry => entry.verdict === 'refuted').length;
+    const falseKeep = upheldFalse;
+    const uncertain = entries.filter(entry => entry.verdict === 'uncertain').length;
+    const upheld = upheldReal + upheldFalse;
+    const precision = upheld ? upheldReal / upheld : 0;
+    const recall = real.length ? upheldReal / real.length : 0;
+    const falseKillRate = real.length ? falseKill / real.length : 0;
+    const falseKeepRate = falseEntries.length ? falseKeep / falseEntries.length : 0;
+    const intervals = {
+        precision: wilson(upheldReal, upheld),
+        recall: wilson(upheldReal, real.length),
+        falseKillRate: wilson(falseKill, real.length),
+        falseKeepRate: wilson(falseKeep, falseEntries.length),
+    };
+    let disposition = 'automate';
+    if (entries.length < policy.minSupport || real.length === 0)
+        disposition = 'abstain';
+    else if (intervals.recall.low < policy.minRecall
+        || intervals.precision.low < policy.minPrecision
+        || intervals.falseKillRate.high > policy.maxFalseKillRate
+        || intervals.falseKeepRate.high > policy.maxFalseKeepRate) {
+        disposition = 'human-review';
+    }
+    return {
+        key, support: entries.length, precision, recall, falseKillRate, falseKeepRate,
+        uncertainRate: entries.length ? uncertain / entries.length : 0,
+        intervals,
+        disposition,
+    };
+}
+export function qualifyJudge(slices, criticalSliceKeys = []) {
+    const automatedSlices = slices.filter(s => s.disposition === 'automate').map(s => s.key);
+    const humanReviewSlices = slices.filter(s => s.disposition === 'human-review').map(s => s.key);
+    const abstainSlices = slices.filter(s => s.disposition === 'abstain').map(s => s.key);
+    const presentKeys = new Set(slices.map(s => s.key));
+    const missingCriticalKeys = criticalSliceKeys.filter(key => !presentKeys.has(key));
+    const criticalFailures = slices.filter(s => criticalSliceKeys.includes(s.key) && s.disposition !== 'automate');
+    const status = criticalFailures.length > 0 || missingCriticalKeys.length > 0
+        ? 'unqualified'
+        : humanReviewSlices.length > 0 || abstainSlices.length > 0
+            ? 'restricted'
+            : 'qualified';
+    return {
+        status, automatedSlices, humanReviewSlices, abstainSlices,
+        reasons: [
+            ...criticalFailures.map(s => `Critical slice ${s.key} is ${s.disposition}`),
+            ...missingCriticalKeys.map(key => `Critical slice ${key} is missing`),
+        ],
+    };
+}
 /** Run the verifier over a labeled set and report the confusion vs ground truth. */
-export async function calibrate(labeled, opts) {
+export async function calibrate(labeled, opts, qualificationOptions = {}) {
     const verdicts = await adversarialVerify(labeled.map((l) => l.finding), opts);
+    const policy = { ...DEFAULT_QUALIFICATION, ...qualificationOptions };
     const r = {
         total: labeled.length, realCount: 0, falseCount: 0,
         falseKill: 0, falseKillRate: 0, falseKeep: 0, falseKeepRate: 0,
-        correctConfirm: 0, correctKill: 0, uncertain: 0,
+        correctConfirm: 0, correctKill: 0, uncertain: 0, slices: [],
+        qualification: {
+            status: 'restricted', automatedSlices: [], humanReviewSlices: [],
+            abstainSlices: [], reasons: [],
+        },
     };
     labeled.forEach((l, i) => {
         const v = verdicts[i].verdict;
@@ -28,6 +107,29 @@ export async function calibrate(labeled, opts) {
     });
     r.falseKillRate = r.realCount ? r.falseKill / r.realCount : 0;
     r.falseKeepRate = r.falseCount ? r.falseKeep / r.falseCount : 0;
+    const entries = labeled.map((label, index) => ({ label, verdict: verdicts[index].verdict }));
+    const groups = new Map();
+    const add = (key, entry) => {
+        const group = groups.get(key) ?? [];
+        group.push(entry);
+        groups.set(key, group);
+    };
+    entries.forEach(entry => {
+        add('overall', entry);
+        if (entry.label.failureType)
+            add(`failureType:${entry.label.failureType}`, entry);
+        if (entry.label.domain)
+            add(`domain:${entry.label.domain}`, entry);
+        const severity = entry.label.expectedSeverity ?? entry.label.finding.severity;
+        add(`severity:${severity}`, entry);
+    });
+    const criticalKeys = policy.criticalSeverities.map(severity => `severity:${severity}`);
+    for (const key of criticalKeys) {
+        if (!groups.has(key))
+            groups.set(key, []);
+    }
+    r.slices = [...groups.entries()].map(([key, group]) => buildSlice(key, group, policy));
+    r.qualification = qualifyJudge(r.slices, criticalKeys);
     return r;
 }
 //# sourceMappingURL=calibrate.js.map

package/dist/verification/adversarial-verify/index.d.ts

@@ -11,10 +11,10 @@
  *   const verdicts = await adversarialVerify(findings, { judge, refuters: 3 });
  *   const { confirmed, killed } = partitionVerdicts(verdicts);
  */
-export type { Finding, FindingVerdict, FindingSeverity, FindingOutcome, RefuterVote, Judge, AdversarialVerifyOptions, } from './types.js';
+export type { Finding, FindingVerdict, FindingSeverity, FindingOutcome, RefuterVote, JudgeMeasurementReceipt, EndpointClass, SnapshotIdentityLevel, ReceiptSemantics, CacheStatus, Judge, AdversarialVerifyOptions, } from './types.js';
 export { adversarialVerify, partitionVerdicts } from './verify.js';
 export { synthesizeVerdict, majorityKill, isFindingVerdict } from './synthesize.js';
 export { refuterPrompt, DEFAULT_LENSES } from './prompts.js';
-export { calibrate, type LabeledFinding, type CalibrationReport } from './calibrate.js';
+export { calibrate, qualifyJudge, type CalibrationReport, type ConfidenceInterval, type JudgeQualification, type LabeledFinding, type QualificationDisposition, type QualificationOptions, type QualificationSlice, } from './calibrate.js';
 export { verifyGate, type VerifyGateOptions, type VerifyGateResult } from './gate.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/verification/adversarial-verify/index.js

@@ -1,6 +1,6 @@
 export { adversarialVerify, partitionVerdicts } from './verify.js';
 export { synthesizeVerdict, majorityKill, isFindingVerdict } from './synthesize.js';
 export { refuterPrompt, DEFAULT_LENSES } from './prompts.js';
-export { calibrate } from './calibrate.js';
+export { calibrate, qualifyJudge, } from './calibrate.js';
 export { verifyGate } from './gate.js';
 //# sourceMappingURL=index.js.map

package/dist/verification/adversarial-verify/measurement-receipt.d.ts

@@ -0,0 +1,13 @@
+import type { JudgeMeasurementReceipt } from './types.js';
+export type ReceiptIdentifierField = 'provider' | 'requestedModel' | 'resolvedModel' | 'fingerprint' | 'windowId' | 'requestId';
+export declare const RECEIPT_IDENTIFIER_PATTERN = "^(?:UNKNOWN|[A-Za-z0-9][A-Za-z0-9._:/@+-]{0,255})$";
+export declare const RECEIPT_SENSITIVE_IDENTIFIER_PATTERN = "(?:^|[._:/@+\\-])(?:(?:[sS][kK]|[rR][kK]|[gG][hH][pPoOuUsSrR]|[gG][iI][tT][hH][uU][bB]_[pP][aA][tT]|[xX][oO][xX][bBaApPrRsS]|[nN][pP][mM]|[gG][lL][pP][aA][tT]|[pP][aA][tT])(?:[-_][A-Za-z0-9_-]*|(?=$|[.:/@+\\-]))|(?:[aA][kK][iI][aA]|[aA][sS][iI][aA]|[aA][iI][zZ][aA])[A-Za-z0-9]*)";
+export declare const RECEIPT_JWT_PATTERN = "(?:^|[^A-Za-z0-9_-])(?:eyJ[A-Za-z0-9_-]*|e30|ew[A-Za-z0-9_-]*)\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+(?:$|[^A-Za-z0-9_-])";
+export declare const RECEIPT_OPAQUE_DESCRIPTOR_PATTERN = "(?:^|[._:/@+\\-])[A-Za-z0-9]{32,}(?:$|[._:/@+\\-])";
+export declare const RECEIPT_OPAQUE_CORRELATION_PATTERN = "(?:(?:^|[.:@\\-])[A-Za-z0-9+/]{32,}={0,2}(?:$|[.:@\\-])|(?:^|[.:/@+\\-])[A-Za-z0-9_-]{48,}(?:$|[.:/@+\\-]))";
+export declare const RECEIPT_KNOWN_TIMESTAMP_PATTERN = "^\\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\\d|3[01])T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d{1,9})?Z$";
+export declare function isSanitizedReceiptIdentifier(candidate: unknown, field: ReceiptIdentifierField): candidate is string;
+export declare function isSanitizedReceiptTimestamp(candidate: unknown): candidate is string;
+/** Convert adapter-supplied receipt evidence into the content-free public contract. */
+export declare function sanitizeJudgeMeasurementReceipt(value: unknown): JudgeMeasurementReceipt;
+//# sourceMappingURL=measurement-receipt.d.ts.map

package/dist/verification/adversarial-verify/measurement-receipt.js

@@ -0,0 +1,136 @@
+const ENDPOINT_CLASSES = new Set(['shared', 'dedicated', 'local', 'UNKNOWN']);
+const SNAPSHOT_LEVELS = new Set(['L0_UNKNOWN', 'L1_NAMED', 'L2_CONTENT_BOUND']);
+const SEMANTICS = new Set(['verified', 'provider-asserted', 'UNKNOWN']);
+const CACHE_STATUSES = new Set(['hit', 'miss', 'bypass', 'UNKNOWN']);
+export const RECEIPT_IDENTIFIER_PATTERN = '^(?:UNKNOWN|[A-Za-z0-9][A-Za-z0-9._:/@+-]{0,255})$';
+export const RECEIPT_SENSITIVE_IDENTIFIER_PATTERN = '(?:^|[._:/@+\\-])(?:(?:[sS][kK]|[rR][kK]|[gG][hH][pPoOuUsSrR]|[gG][iI][tT][hH][uU][bB]_[pP][aA][tT]|[xX][oO][xX][bBaApPrRsS]|[nN][pP][mM]|[gG][lL][pP][aA][tT]|[pP][aA][tT])(?:[-_][A-Za-z0-9_-]*|(?=$|[.:/@+\\-]))|(?:[aA][kK][iI][aA]|[aA][sS][iI][aA]|[aA][iI][zZ][aA])[A-Za-z0-9]*)';
+export const RECEIPT_JWT_PATTERN = '(?:^|[^A-Za-z0-9_-])(?:eyJ[A-Za-z0-9_-]*|e30|ew[A-Za-z0-9_-]*)\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+(?:$|[^A-Za-z0-9_-])';
+export const RECEIPT_OPAQUE_DESCRIPTOR_PATTERN = '(?:^|[._:/@+\\-])[A-Za-z0-9]{32,}(?:$|[._:/@+\\-])';
+export const RECEIPT_OPAQUE_CORRELATION_PATTERN = '(?:(?:^|[.:@\\-])[A-Za-z0-9+/]{32,}={0,2}(?:$|[.:@\\-])|(?:^|[.:/@+\\-])[A-Za-z0-9_-]{48,}(?:$|[.:/@+\\-]))';
+export const RECEIPT_KNOWN_TIMESTAMP_PATTERN = '^\\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\\d|3[01])T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d{1,9})?Z$';
+const SAFE_IDENTIFIER = new RegExp(RECEIPT_IDENTIFIER_PATTERN);
+const SENSITIVE_IDENTIFIER = new RegExp(RECEIPT_SENSITIVE_IDENTIFIER_PATTERN);
+const JWT = new RegExp(RECEIPT_JWT_PATTERN);
+const OPAQUE_DESCRIPTOR = new RegExp(RECEIPT_OPAQUE_DESCRIPTOR_PATTERN);
+const OPAQUE_CORRELATION = new RegExp(RECEIPT_OPAQUE_CORRELATION_PATTERN);
+const KNOWN_TIMESTAMP = new RegExp(RECEIPT_KNOWN_TIMESTAMP_PATTERN);
+const RECEIPT_HASH_FIELDS = [
+    'requestHash', 'promptHash', 'configHash', 'parserSchemaHash', 'outputHash', 'parsedVoteHash',
+];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function looksLikeOpaqueCredential(value, field) {
+    if (SENSITIVE_IDENTIFIER.test(value) || JWT.test(value))
+        return true;
+    if (field === 'provider' || field === 'requestedModel' || field === 'resolvedModel') {
+        return OPAQUE_DESCRIPTOR.test(value);
+    }
+    return OPAQUE_CORRELATION.test(value);
+}
+export function isSanitizedReceiptIdentifier(candidate, field) {
+    return typeof candidate === 'string'
+        && SAFE_IDENTIFIER.test(candidate)
+        && !looksLikeOpaqueCredential(candidate, field);
+}
+function identifier(candidate, field) {
+    return typeof candidate === 'string'
+        && isSanitizedReceiptIdentifier(candidate, field)
+        ? candidate
+        : 'UNKNOWN';
+}
+export function isSanitizedReceiptTimestamp(candidate) {
+    if (candidate === 'UNKNOWN')
+        return true;
+    if (typeof candidate !== 'string' || !KNOWN_TIMESTAMP.test(candidate))
+        return false;
+    const [date] = candidate.split('T');
+    const [yearText, monthText, dayText] = date.split('-');
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return day <= daysInMonth[month - 1];
+}
+function timestamp(candidate) {
+    return isSanitizedReceiptTimestamp(candidate) ? candidate : 'UNKNOWN';
+}
+function hash(candidate) {
+    return typeof candidate === 'string' && /^(?:sha256:)?[a-f\d]{64}$/i.test(candidate)
+        ? `sha256:${candidate.replace(/^sha256:/i, '').toLowerCase()}`
+        : 'UNKNOWN';
+}
+function enumOr(candidate, allowed, fallback) {
+    return typeof candidate === 'string' && allowed.has(candidate) ? candidate : fallback;
+}
+function finiteNonNegativeOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function unitOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1 ? value : null;
+}
+function unknownReceipt() {
+    return {
+        contract: 'judge-measurement@1',
+        provider: 'UNKNOWN', requestedModel: 'UNKNOWN', resolvedModel: 'UNKNOWN',
+        endpointClass: 'UNKNOWN', snapshotIdentity: 'L0_UNKNOWN', semantics: 'UNKNOWN',
+        fingerprint: 'UNKNOWN', requestHash: 'UNKNOWN', promptHash: 'UNKNOWN', configHash: 'UNKNOWN',
+        parserSchemaHash: 'UNKNOWN', outputHash: 'UNKNOWN', parsedVoteHash: 'UNKNOWN',
+        temperature: null, topP: null, seed: null, deterministic: null, cacheStatus: 'UNKNOWN',
+        retryCount: 0, timestamp: 'UNKNOWN', windowId: 'UNKNOWN', latencyMs: null, requestId: 'UNKNOWN',
+    };
+}
+/** Convert adapter-supplied receipt evidence into the content-free public contract. */
+export function sanitizeJudgeMeasurementReceipt(value) {
+    if (!isRecord(value))
+        return unknownReceipt();
+    try {
+        const sanitized = {
+            contract: 'judge-measurement@1',
+            provider: identifier(value.provider, 'provider'),
+            requestedModel: identifier(value.requestedModel, 'requestedModel'),
+            resolvedModel: identifier(value.resolvedModel, 'resolvedModel'),
+            endpointClass: enumOr(value.endpointClass, ENDPOINT_CLASSES, 'UNKNOWN'),
+            snapshotIdentity: enumOr(value.snapshotIdentity, SNAPSHOT_LEVELS, 'L0_UNKNOWN'),
+            semantics: enumOr(value.semantics, SEMANTICS, 'UNKNOWN'),
+            fingerprint: identifier(value.fingerprint, 'fingerprint'),
+            requestHash: hash(value.requestHash),
+            promptHash: hash(value.promptHash),
+            configHash: hash(value.configHash),
+            parserSchemaHash: hash(value.parserSchemaHash),
+            outputHash: hash(value.outputHash),
+            parsedVoteHash: hash(value.parsedVoteHash),
+            temperature: finiteNonNegativeOrNull(value.temperature),
+            topP: unitOrNull(value.topP),
+            seed: typeof value.seed === 'number' && Number.isSafeInteger(value.seed) ? value.seed : null,
+            deterministic: typeof value.deterministic === 'boolean' ? value.deterministic : null,
+            cacheStatus: enumOr(value.cacheStatus, CACHE_STATUSES, 'UNKNOWN'),
+            retryCount: typeof value.retryCount === 'number' && Number.isSafeInteger(value.retryCount) && value.retryCount >= 0
+                ? value.retryCount
+                : 0,
+            timestamp: timestamp(value.timestamp),
+            windowId: identifier(value.windowId, 'windowId'),
+            latencyMs: finiteNonNegativeOrNull(value.latencyMs),
+            requestId: identifier(value.requestId, 'requestId'),
+        };
+        const contentBound = sanitized.fingerprint !== 'UNKNOWN'
+            && RECEIPT_HASH_FIELDS.every((field) => sanitized[field] !== 'UNKNOWN');
+        const namedSnapshot = sanitized.resolvedModel !== 'UNKNOWN';
+        if ((sanitized.snapshotIdentity === 'L2_CONTENT_BOUND' && !contentBound)
+            || (sanitized.snapshotIdentity === 'L1_NAMED' && !namedSnapshot)) {
+            sanitized.snapshotIdentity = 'L0_UNKNOWN';
+        }
+        if (sanitized.snapshotIdentity === 'L0_UNKNOWN'
+            || sanitized.fingerprint === 'UNKNOWN'
+            || (sanitized.semantics === 'verified'
+                && (sanitized.snapshotIdentity !== 'L2_CONTENT_BOUND' || !contentBound))) {
+            sanitized.semantics = 'UNKNOWN';
+        }
+        return sanitized;
+    }
+    catch {
+        return unknownReceipt();
+    }
+}
+//# sourceMappingURL=measurement-receipt.js.map

package/dist/verification/adversarial-verify/synthesize.js

@@ -1,3 +1,5 @@
+import { validateFindingVerdict } from '../../contracts/verdicts.js';
+import { sanitizeJudgeMeasurementReceipt } from './measurement-receipt.js';
 /** Default kill threshold: simple majority of cast votes (2-of-3, 1-of-1, 2-of-2). */
 export const majorityKill = (castVotes) => Math.ceil(castVotes / 2);
 /**
@@ -6,6 +8,9 @@ export const majorityKill = (castVotes) => Math.ceil(castVotes / 2);
  */
 export function synthesizeVerdict(finding, votes, killThreshold = majorityKill) {
     const refutations = votes.filter((v) => v.refuted).map((v) => v.reasoning);
+    const measurementReceipts = votes.flatMap((v) => v.measurementReceipt
+        ? [sanitizeJudgeMeasurementReceipt(v.measurementReceipt)]
+        : []);
     const killed = votes.length > 0 && refutations.length >= killThreshold(votes.length);
     return {
         contract: 'finding-verdict@1',
@@ -17,19 +22,11 @@ export function synthesizeVerdict(finding, votes, killThreshold = majorityKill)
         evidence: finding.evidence,
         verdict: votes.length === 0 ? 'uncertain' : killed ? 'refuted' : 'upheld',
         refutations,
+        ...(measurementReceipts.length > 0 ? { measurementReceipts } : {}),
     };
 }
 /** Runtime guard: does `x` conform to finding-verdict@1 at the boundary? */
 export function isFindingVerdict(x) {
-    if (!x || typeof x !== 'object')
-        return false;
-    const v = x;
-    return (v.contract === 'finding-verdict@1' &&
-        typeof v.id === 'string' &&
-        typeof v.title === 'string' &&
-        typeof v.confidence === 'number' &&
-        Array.isArray(v.evidence) &&
-        Array.isArray(v.refutations) &&
-        (v.verdict === 'upheld' || v.verdict === 'refuted' || v.verdict === 'uncertain'));
+    return validateFindingVerdict(x).valid;
 }
 //# sourceMappingURL=synthesize.js.map

package/dist/verification/adversarial-verify/types.d.ts

@@ -8,6 +8,10 @@
  */
 export type FindingSeverity = 'critical' | 'high' | 'medium' | 'low' | 'info';
 export type FindingOutcome = 'upheld' | 'refuted' | 'uncertain';
+export type EndpointClass = 'shared' | 'dedicated' | 'local' | 'UNKNOWN';
+export type SnapshotIdentityLevel = 'L0_UNKNOWN' | 'L1_NAMED' | 'L2_CONTENT_BOUND';
+export type ReceiptSemantics = 'verified' | 'provider-asserted' | 'UNKNOWN';
+export type CacheStatus = 'hit' | 'miss' | 'bypass' | 'UNKNOWN';
 /** A claim to be adversarially verified (input). */
 export interface Finding {
     /** Stable id; the verdict carries it verbatim (callers compose any prefix). */
@@ -23,6 +27,35 @@ export interface Finding {
 export interface RefuterVote {
     refuted: boolean;
     reasoning: string;
+    /** Optional sanitized identity/configuration evidence supplied by a real adapter. */
+    measurementReceipt?: JudgeMeasurementReceipt;
+}
+/** Hash-bound, content-free evidence for one judge request and parsed vote. */
+export interface JudgeMeasurementReceipt {
+    contract: 'judge-measurement@1';
+    provider: string;
+    requestedModel: string;
+    resolvedModel: string;
+    endpointClass: EndpointClass;
+    snapshotIdentity: SnapshotIdentityLevel;
+    semantics: ReceiptSemantics;
+    fingerprint: string;
+    requestHash: string;
+    promptHash: string;
+    configHash: string;
+    parserSchemaHash: string;
+    outputHash: string;
+    parsedVoteHash: string;
+    temperature: number | null;
+    topP: number | null;
+    seed: number | null;
+    deterministic: boolean | null;
+    cacheStatus: CacheStatus;
+    retryCount: number;
+    timestamp: string;
+    windowId: string;
+    latencyMs: number | null;
+    requestId: string;
 }
 /**
  * The injected LLM refuter. Returns a vote, or `null`/throws on failure (failed
@@ -42,6 +75,8 @@ export interface FindingVerdict {
     verdict: FindingOutcome;
     /** One entry per refuter that voted to refute (empty when none). */
     refutations: string[];
+    /** Sanitized receipts for cast votes whose adapters supplied measurement evidence. */
+    measurementReceipts?: JudgeMeasurementReceipt[];
 }
 export interface AdversarialVerifyOptions {
     /** The injected LLM refuter. Required. */

package/dist/verification/adversarial-verify/verify.js

@@ -1,10 +1,15 @@
 import { DEFAULT_LENSES, refuterPrompt } from './prompts.js';
 import { majorityKill, synthesizeVerdict } from './synthesize.js';
+import { sanitizeJudgeMeasurementReceipt } from './measurement-receipt.js';
 /** Call one refuter; a thrown/`null` result is a failed vote (excluded). */
 async function castVote(judge, finding, lens) {
     try {
         const v = await judge(refuterPrompt(finding, lens));
-        return v && typeof v.refuted === 'boolean' ? { refuted: v.refuted, reasoning: String(v.reasoning ?? '') } : null;
+        return v && typeof v.refuted === 'boolean' ? {
+            refuted: v.refuted,
+            reasoning: String(v.reasoning ?? ''),
+            ...(v.measurementReceipt ? { measurementReceipt: sanitizeJudgeMeasurementReceipt(v.measurementReceipt) } : {}),
+        } : null;
     }
     catch {
         return null;