agentic-qe 3.13.12 → 3.14.1

package/dist/contracts/verdicts.js

@@ -1,17 +1,4 @@
-/**
- * Agentic QE v3 - Structured Verdict Contracts (ADR-103)
- *
- * Typed, versioned verdict envelopes for agent-to-agent and MCP-boundary
- * handoffs: RiskDecision (quality gates), FindingVerdict (review findings
- * with adversarial refutations), CoverageGap (risk-weighted gap reports).
- *
- * Validators are dependency-free and are the source of truth; the exported
- * JSON Schemas (published to schemas/*.schema.json by
- * scripts/generate-verdict-schemas.mjs) mirror them for external tooling
- * (ajv, workflow agent() schema option). Envelopes are versioned and
- * additive-only within a major version: consumers must tolerate unknown
- * fields, so schemas keep `additionalProperties: true`.
- */
+import { isSanitizedReceiptIdentifier, isSanitizedReceiptTimestamp, RECEIPT_IDENTIFIER_PATTERN, RECEIPT_JWT_PATTERN, RECEIPT_KNOWN_TIMESTAMP_PATTERN, RECEIPT_OPAQUE_CORRELATION_PATTERN, RECEIPT_OPAQUE_DESCRIPTOR_PATTERN, RECEIPT_SENSITIVE_IDENTIFIER_PATTERN, } from '../verification/adversarial-verify/measurement-receipt.js';
 export const VERDICT_CONTRACT_VERSION = '1.0';
 // ============================================================================
 // Validators (dependency-free, boundary-grade)
@@ -25,6 +12,88 @@ function isStringArray(v) {
 function inUnitRange(v) {
     return typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1;
 }
+const RECEIPT_KEYS = new Set([
+    'contract', 'provider', 'requestedModel', 'resolvedModel', 'endpointClass', 'snapshotIdentity',
+    'semantics', 'fingerprint', 'requestHash', 'promptHash', 'configHash', 'parserSchemaHash',
+    'outputHash', 'parsedVoteHash', 'temperature', 'topP', 'seed', 'deterministic', 'cacheStatus',
+    'retryCount', 'timestamp', 'windowId', 'latencyMs', 'requestId',
+]);
+const RECEIPT_HASH = /^(?:UNKNOWN|sha256:[a-f\d]{64})$/;
+function validateMeasurementReceipt(value, path) {
+    if (!isRecord(value))
+        return [`${path} must be an object`];
+    const errors = [];
+    for (const key of Object.keys(value)) {
+        if (!RECEIPT_KEYS.has(key))
+            errors.push(`${path}.${key} is not allowed`);
+    }
+    if (value.contract !== 'judge-measurement@1')
+        errors.push(`${path}.contract must be "judge-measurement@1"`);
+    for (const key of ['provider', 'requestedModel', 'resolvedModel', 'fingerprint', 'windowId', 'requestId']) {
+        if (!isSanitizedReceiptIdentifier(value[key], key)) {
+            errors.push(`${path}.${key} must be a sanitized identifier`);
+        }
+    }
+    for (const key of ['requestHash', 'promptHash', 'configHash', 'parserSchemaHash', 'outputHash', 'parsedVoteHash']) {
+        if (typeof value[key] !== 'string' || !RECEIPT_HASH.test(value[key])) {
+            errors.push(`${path}.${key} must be UNKNOWN or a SHA-256 digest`);
+        }
+    }
+    if (!['shared', 'dedicated', 'local', 'UNKNOWN'].includes(value.endpointClass)) {
+        errors.push(`${path}.endpointClass is invalid`);
+    }
+    if (!['L0_UNKNOWN', 'L1_NAMED', 'L2_CONTENT_BOUND'].includes(value.snapshotIdentity)) {
+        errors.push(`${path}.snapshotIdentity is invalid`);
+    }
+    if (!['verified', 'provider-asserted', 'UNKNOWN'].includes(value.semantics)) {
+        errors.push(`${path}.semantics is invalid`);
+    }
+    if (!['hit', 'miss', 'bypass', 'UNKNOWN'].includes(value.cacheStatus)) {
+        errors.push(`${path}.cacheStatus is invalid`);
+    }
+    if (value.temperature !== null && (typeof value.temperature !== 'number'
+        || !Number.isFinite(value.temperature) || value.temperature < 0)) {
+        errors.push(`${path}.temperature must be a non-negative finite number or null`);
+    }
+    if (value.topP !== null && (typeof value.topP !== 'number'
+        || !Number.isFinite(value.topP) || value.topP < 0 || value.topP > 1)) {
+        errors.push(`${path}.topP must be a finite number in [0,1] or null`);
+    }
+    if (value.seed !== null && (typeof value.seed !== 'number' || !Number.isSafeInteger(value.seed))) {
+        errors.push(`${path}.seed must be a safe integer or null`);
+    }
+    if (value.deterministic !== null && typeof value.deterministic !== 'boolean') {
+        errors.push(`${path}.deterministic must be a boolean or null`);
+    }
+    if (!Number.isSafeInteger(value.retryCount) || value.retryCount < 0) {
+        errors.push(`${path}.retryCount must be a non-negative safe integer`);
+    }
+    if (!isSanitizedReceiptTimestamp(value.timestamp)) {
+        errors.push(`${path}.timestamp must be UNKNOWN or an ISO-8601 UTC timestamp`);
+    }
+    if (value.latencyMs !== null && (typeof value.latencyMs !== 'number'
+        || !Number.isFinite(value.latencyMs) || value.latencyMs < 0)) {
+        errors.push(`${path}.latencyMs must be a non-negative finite number or null`);
+    }
+    const contentBound = value.fingerprint !== 'UNKNOWN'
+        && ['requestHash', 'promptHash', 'configHash', 'parserSchemaHash', 'outputHash', 'parsedVoteHash']
+            .every((field) => value[field] !== 'UNKNOWN');
+    if (value.snapshotIdentity === 'L2_CONTENT_BOUND' && !contentBound) {
+        errors.push(`${path}.snapshotIdentity L2_CONTENT_BOUND requires non-UNKNOWN fingerprint and hashes`);
+    }
+    if (value.snapshotIdentity === 'L1_NAMED' && value.resolvedModel === 'UNKNOWN') {
+        errors.push(`${path}.snapshotIdentity L1_NAMED requires a resolved model`);
+    }
+    if (value.semantics === 'verified'
+        && (value.snapshotIdentity !== 'L2_CONTENT_BOUND' || !contentBound)) {
+        errors.push(`${path}.semantics verified requires L2 content-bound identity`);
+    }
+    if (value.semantics !== 'UNKNOWN'
+        && (value.snapshotIdentity === 'L0_UNKNOWN' || value.fingerprint === 'UNKNOWN')) {
+        errors.push(`${path}.semantics requires identified snapshot and fingerprint`);
+    }
+    return errors;
+}
 export function validateRiskDecision(value) {
     const errors = [];
     if (!isRecord(value))
@@ -67,6 +136,16 @@ export function validateFindingVerdict(value) {
     }
     if (!isStringArray(value.refutations))
         errors.push('refutations must be string[]');
+    if (value.measurementReceipts !== undefined) {
+        if (!Array.isArray(value.measurementReceipts)) {
+            errors.push('measurementReceipts must be an array when present');
+        }
+        else {
+            value.measurementReceipts.forEach((receipt, index) => {
+                errors.push(...validateMeasurementReceipt(receipt, `measurementReceipts[${index}]`));
+            });
+        }
+    }
     return { valid: errors.length === 0, errors };
 }
 export function validateCoverageGap(value) {
@@ -120,6 +199,22 @@ export function buildRiskDecisionFromQualityGate(input) {
 // ============================================================================
 const unit = { type: 'number', minimum: 0, maximum: 1 };
 const stringArray = { type: 'array', items: { type: 'string' } };
+function receiptIdentifier(field) {
+    const opaquePattern = field === 'provider' || field === 'requestedModel' || field === 'resolvedModel'
+        ? RECEIPT_OPAQUE_DESCRIPTOR_PATTERN
+        : RECEIPT_OPAQUE_CORRELATION_PATTERN;
+    return {
+        type: 'string',
+        pattern: RECEIPT_IDENTIFIER_PATTERN,
+        allOf: [
+            { not: { pattern: RECEIPT_SENSITIVE_IDENTIFIER_PATTERN } },
+            { not: { pattern: RECEIPT_JWT_PATTERN } },
+            { not: { pattern: opaquePattern } },
+        ],
+    };
+}
+const receiptHash = { type: 'string', pattern: '^(?:UNKNOWN|sha256:[a-f0-9]{64})$' };
+const knownReceiptHash = { type: 'string', pattern: '^sha256:[a-f0-9]{64}$' };
 export const RISK_DECISION_SCHEMA = {
     $schema: 'http://json-schema.org/draft-07/schema#',
     $id: 'https://agentic-qe.dev/schemas/risk-decision.schema.json',
@@ -152,6 +247,99 @@ export const FINDING_VERDICT_SCHEMA = {
         evidence: stringArray,
         verdict: { enum: ['upheld', 'refuted', 'uncertain'] },
         refutations: stringArray,
+        measurementReceipts: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: [
+                    'contract', 'provider', 'requestedModel', 'resolvedModel', 'endpointClass',
+                    'snapshotIdentity', 'semantics', 'fingerprint', 'requestHash', 'promptHash',
+                    'configHash', 'parserSchemaHash', 'outputHash', 'parsedVoteHash', 'temperature',
+                    'topP', 'seed', 'deterministic', 'cacheStatus', 'retryCount', 'timestamp',
+                    'windowId', 'latencyMs', 'requestId',
+                ],
+                additionalProperties: false,
+                properties: {
+                    contract: { const: 'judge-measurement@1' },
+                    provider: receiptIdentifier('provider'),
+                    requestedModel: receiptIdentifier('requestedModel'),
+                    resolvedModel: receiptIdentifier('resolvedModel'),
+                    endpointClass: { enum: ['shared', 'dedicated', 'local', 'UNKNOWN'] },
+                    snapshotIdentity: { enum: ['L0_UNKNOWN', 'L1_NAMED', 'L2_CONTENT_BOUND'] },
+                    semantics: { enum: ['verified', 'provider-asserted', 'UNKNOWN'] },
+                    fingerprint: receiptIdentifier('fingerprint'),
+                    requestHash: receiptHash,
+                    promptHash: receiptHash,
+                    configHash: receiptHash,
+                    parserSchemaHash: receiptHash,
+                    outputHash: receiptHash,
+                    parsedVoteHash: receiptHash,
+                    temperature: { type: ['number', 'null'], minimum: 0 },
+                    topP: { type: ['number', 'null'], minimum: 0, maximum: 1 },
+                    seed: {
+                        type: ['integer', 'null'],
+                        minimum: Number.MIN_SAFE_INTEGER,
+                        maximum: Number.MAX_SAFE_INTEGER,
+                    },
+                    deterministic: { type: ['boolean', 'null'] },
+                    cacheStatus: { enum: ['hit', 'miss', 'bypass', 'UNKNOWN'] },
+                    retryCount: { type: 'integer', minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
+                    timestamp: {
+                        anyOf: [
+                            { const: 'UNKNOWN' },
+                            { type: 'string', pattern: RECEIPT_KNOWN_TIMESTAMP_PATTERN, format: 'date-time' },
+                        ],
+                    },
+                    windowId: receiptIdentifier('windowId'),
+                    latencyMs: { type: ['number', 'null'], minimum: 0 },
+                    requestId: receiptIdentifier('requestId'),
+                },
+                allOf: [
+                    {
+                        if: { properties: { snapshotIdentity: { const: 'L2_CONTENT_BOUND' } } },
+                        then: {
+                            properties: {
+                                fingerprint: { not: { const: 'UNKNOWN' } },
+                                requestHash: knownReceiptHash,
+                                promptHash: knownReceiptHash,
+                                configHash: knownReceiptHash,
+                                parserSchemaHash: knownReceiptHash,
+                                outputHash: knownReceiptHash,
+                                parsedVoteHash: knownReceiptHash,
+                            },
+                        },
+                    },
+                    {
+                        if: { properties: { snapshotIdentity: { const: 'L1_NAMED' } } },
+                        then: { properties: { resolvedModel: { not: { const: 'UNKNOWN' } } } },
+                    },
+                    {
+                        if: { properties: { semantics: { const: 'verified' } } },
+                        then: {
+                            properties: {
+                                snapshotIdentity: { const: 'L2_CONTENT_BOUND' },
+                                fingerprint: { not: { const: 'UNKNOWN' } },
+                                requestHash: knownReceiptHash,
+                                promptHash: knownReceiptHash,
+                                configHash: knownReceiptHash,
+                                parserSchemaHash: knownReceiptHash,
+                                outputHash: knownReceiptHash,
+                                parsedVoteHash: knownReceiptHash,
+                            },
+                        },
+                    },
+                    {
+                        if: { properties: { semantics: { enum: ['verified', 'provider-asserted'] } } },
+                        then: {
+                            properties: {
+                                snapshotIdentity: { not: { const: 'L0_UNKNOWN' } },
+                                fingerprint: { not: { const: 'UNKNOWN' } },
+                            },
+                        },
+                    },
+                ],
+            },
+        },
     },
 };
 export const COVERAGE_GAP_SCHEMA = {

package/dist/coordination/handlers/coverage-handlers.js

@@ -120,10 +120,17 @@ async function collectCoverage(targetPath) {
         return { collected: fromReport, ranTests: false };
     }
     // #569 work item 1: delegate to real instrumentation where available.
-    if (isRustProject(targetPath)) {
+    const rustProject = isRustProject(targetPath);
+    if (rustProject) {
         const rust = await collectRustCoverage(targetPath);
         if (rust)
             return { collected: rust, ranTests: true };
+        // This target is a Rust crate. Do not continue into the JS/TS runner:
+        // `npx vitest --coverage` can still be available through the parent
+        // process PATH and will write an empty report even though the crate has no
+        // JavaScript tests. Treating that artifact as coverage hides the intended
+        // Rust static-estimation fallback and mislabels the result.
+        return { collected: buildEstimatedCoverage(targetPath), ranTests: false };
     }
     const ranTests = await tryRunJsCoverage(targetPath);
     const afterRun = await loadCoverageData(targetPath);

package/dist/domains/chaos-resilience/diagnosis/corpus.d.ts

@@ -0,0 +1,5 @@
+import { type AgentFaultCorpus, type AgentFaultCorpusCase } from './types.js';
+/** Frozen, synthetic corpus. Ground truth is never embedded in detectorInput. */
+export declare function createAgentFaultDiagnosisCorpus(): AgentFaultCorpus;
+export declare function serializeDetectorInput(input: AgentFaultCorpusCase['detectorInput']): string;
+//# sourceMappingURL=corpus.d.ts.map

package/dist/domains/chaos-resilience/diagnosis/corpus.js

@@ -0,0 +1,141 @@
+import { createHash } from 'node:crypto';
+import { AGENT_FAULT_CORPUS_SCHEMA_VERSION, AGENT_FAULT_TRACE_SCHEMA_VERSION, } from './types.js';
+const SOURCE_REVISION = 'fixture-source-v1';
+const HARNESS_REVISION = 'agent-runtime-diagnosis-v1';
+const ENVIRONMENT_DIGEST = sha256('synthetic-node-runtime-v1');
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function stable(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stable(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function span(spanId, componentId, kind, parentSpanId) {
+    const input = `input:${componentId}`;
+    const output = `output:${componentId}`;
+    return {
+        spanId,
+        ...(parentSpanId ? { parentSpanId } : {}),
+        componentId,
+        kind,
+        startOffsetMs: kind === 'run' ? 0 : 10,
+        durationMs: kind === 'run' ? 100 : 20,
+        status: 'ok',
+        inputBytes: Buffer.byteLength(input),
+        outputBytes: Buffer.byteLength(output),
+        inputHash: sha256(input),
+        outputHash: sha256(output),
+        recovered: false,
+    };
+}
+function baseSpans() {
+    return [
+        span('run', 'workflow', 'run'),
+        span('agent-primary', 'planner', 'agent', 'run'),
+        { ...span('tool-weather', 'weather-tool', 'tool', 'agent-primary'), intendedDestination: 'weather-tool', actualDestination: 'weather-tool' },
+        span('model-answer', 'reasoning-model', 'model', 'agent-primary'),
+        { ...span('policy-check', 'safety-policy', 'guardrail', 'agent-primary'), policyRef: 'policy://safety/v1', expectedDecision: 'deny', actualDecision: 'deny' },
+        { ...span('delegate-review', 'reviewer-agent', 'delegation', 'agent-primary'), intendedDestination: 'reviewer-agent', actualDestination: 'reviewer-agent' },
+    ];
+}
+const FIXTURES = [
+    { faultType: 'tool-unavailable', boundary: 'tool', componentId: 'weather-tool', spanId: 'tool-weather', signal: 'tool unavailable', mutate: (s) => ({ ...s, status: 'error', signalCode: 'TOOL_UNAVAILABLE', outputBytes: 0, outputHash: sha256('') }) },
+    { faultType: 'tool-timeout', boundary: 'tool', componentId: 'weather-tool', spanId: 'tool-weather', signal: 'tool deadline exceeded', mutate: (s) => ({ ...s, status: 'timeout', signalCode: 'DEADLINE_EXCEEDED', durationMs: 5_000 }) },
+    { faultType: 'corrupted-tool-output', boundary: 'tool', componentId: 'weather-tool', spanId: 'tool-weather', signal: 'output differs from aligned clean reference', mutate: (s) => ({ ...s, outputHash: sha256('plausible-but-wrong'), outputBytes: 19 }) },
+    { faultType: 'context-truncation', boundary: 'model-context', componentId: 'reasoning-model', spanId: 'model-answer', signal: 'context truncated', mutate: (s) => ({ ...s, status: 'error', signalCode: 'CONTEXT_TRUNCATED', inputBytes: 131_072 }) },
+    { faultType: 'delegation-timeout', boundary: 'inter-agent', componentId: 'reviewer-agent', spanId: 'delegate-review', signal: 'delegation deadline exceeded', mutate: (s) => ({ ...s, status: 'timeout', signalCode: 'DELEGATION_TIMEOUT', durationMs: 5_000 }) },
+    { faultType: 'agent-misroute', boundary: 'inter-agent', componentId: 'reviewer-agent', spanId: 'delegate-review', signal: 'actual agent differs from intended agent', mutate: (s) => ({ ...s, actualDestination: 'billing-agent' }) },
+    { faultType: 'delegation-loop', boundary: 'inter-agent', componentId: 'reviewer-agent', spanId: 'delegate-review', signal: 'delegation edge repeats', mutate: (s) => ({ ...s, retry: 4, signalCode: 'DELEGATION_REPEATED' }) },
+    { faultType: 'guardrail-bypass', boundary: 'guardrail', componentId: 'safety-policy', spanId: 'policy-check', signal: 'policy oracle denies but runtime allows', mutate: (s) => ({ ...s, actualDecision: 'allow' }) },
+];
+function trace(runId, taskId, spans) {
+    return {
+        schemaVersion: AGENT_FAULT_TRACE_SCHEMA_VERSION,
+        runId,
+        taskId,
+        harnessRevision: HARNESS_REVISION,
+        terminalOutcome: 'completed',
+        spans,
+    };
+}
+function structured(raw) {
+    return {
+        schemaVersion: raw.schemaVersion,
+        runId: raw.runId,
+        taskId: raw.taskId,
+        terminalOutcome: raw.terminalOutcome,
+        spans: [...raw.spans].sort((a, b) => a.startOffsetMs - b.startOffsetMs || a.spanId.localeCompare(b.spanId)),
+    };
+}
+function makeCase(caseId, runId, taskId, truth, spans, cleanReference, cleanReferenceId, expectedObservableSignal = 'no fault signal') {
+    const raw = trace(runId, taskId, spans);
+    return {
+        caseId,
+        ...(cleanReferenceId ? { cleanReferenceId } : {}),
+        detectorInput: { trace: raw, structured: structured(raw), ...(cleanReference ? { cleanReference } : {}) },
+        heldOut: {
+            truth,
+            manifest: {
+                schemaVersion: AGENT_FAULT_CORPUS_SCHEMA_VERSION,
+                caseId,
+                runId,
+                taskId,
+                sourceRevision: SOURCE_REVISION,
+                environmentDigest: ENVIRONMENT_DIGEST,
+                seed: 649,
+                target: { boundary: truth.boundary, componentId: truth.componentId, spanId: truth.spanId },
+                parameters: { synthetic: true },
+                expectedObservableSignal,
+                cleanup: { required: false, state: 'not-required', witness: 'synthetic fixture; no side effects' },
+            },
+        },
+    };
+}
+/** Frozen, synthetic corpus. Ground truth is never embedded in detectorInput. */
+export function createAgentFaultDiagnosisCorpus() {
+    const cases = [];
+    FIXTURES.forEach((fixture, index) => {
+        const ordinal = String(index + 1).padStart(3, '0');
+        const taskId = `task-${ordinal}`;
+        const cleanCaseId = `case-${ordinal}-a`;
+        const cleanSpans = baseSpans();
+        const cleanRaw = trace(`run-${ordinal}-a`, taskId, cleanSpans);
+        const cleanView = structured(cleanRaw);
+        const cleanTruth = { faultType: 'none', boundary: 'control', componentId: 'workflow', spanId: 'run' };
+        cases.push(makeCase(cleanCaseId, `run-${ordinal}-a`, taskId, cleanTruth, cleanSpans));
+        const faultySpans = cleanSpans.map((item) => item.spanId === fixture.spanId ? fixture.mutate(item) : item);
+        const truth = {
+            faultType: fixture.faultType,
+            boundary: fixture.boundary,
+            componentId: fixture.componentId,
+            spanId: fixture.spanId,
+        };
+        cases.push(makeCase(`case-${ordinal}-b`, `run-${ordinal}-b`, taskId, truth, faultySpans, cleanView, cleanCaseId, fixture.signal));
+    });
+    const casesDigest = sha256(stable(cases.map(({ caseId, cleanReferenceId, detectorInput, heldOut }) => ({
+        caseId, cleanReferenceId, detectorInput, heldOut,
+    }))));
+    return {
+        manifest: {
+            schemaVersion: AGENT_FAULT_CORPUS_SCHEMA_VERSION,
+            corpusId: `aqe-agent-faults-${casesDigest.slice(0, 16)}`,
+            sourceRevision: SOURCE_REVISION,
+            harnessRevision: HARNESS_REVISION,
+            caseCount: cases.length,
+            casesDigest,
+            mixedFaults: 'out-of-scope',
+            detectorInputExcludes: ['injection manifest', 'ground-truth fault type', 'ground-truth location', 'fixture path'],
+        },
+        cases,
+    };
+}
+export function serializeDetectorInput(input) {
+    return stable(input);
+}
+//# sourceMappingURL=corpus.js.map

package/dist/domains/chaos-resilience/diagnosis/detectors.d.ts

@@ -0,0 +1,11 @@
+import type { AgentFaultDetector } from './types.js';
+/** A transparent baseline limited to explicit runtime signals. */
+export declare const directSignalBaseline: AgentFaultDetector;
+/**
+ * AQE reference-aware diagnosis. It adds paired-output comparison and a policy
+ * oracle to the direct-signal baseline; neither source is a hidden fault label.
+ */
+export declare const referenceAwareAqeDetector: AgentFaultDetector;
+/** Negative-control detector used to prove majority-class guessing cannot pass. */
+export declare const majorityFaultDetector: AgentFaultDetector;
+//# sourceMappingURL=detectors.d.ts.map

package/dist/domains/chaos-resilience/diagnosis/detectors.js

@@ -0,0 +1,109 @@
+function directSignal(span) {
+    if (span.signalCode === 'TOOL_UNAVAILABLE')
+        return { faultType: 'tool-unavailable', boundary: 'tool', confidence: 1 };
+    if (span.kind === 'tool' && span.status === 'timeout')
+        return { faultType: 'tool-timeout', boundary: 'tool', confidence: 1 };
+    if (span.signalCode === 'CONTEXT_TRUNCATED')
+        return { faultType: 'context-truncation', boundary: 'model-context', confidence: 1 };
+    if (span.kind === 'delegation' && span.status === 'timeout')
+        return { faultType: 'delegation-timeout', boundary: 'inter-agent', confidence: 1 };
+    if (span.kind === 'delegation' && span.intendedDestination !== span.actualDestination) {
+        return { faultType: 'agent-misroute', boundary: 'inter-agent', confidence: 1 };
+    }
+    if (span.kind === 'delegation' && (span.retry ?? 0) >= 3) {
+        return { faultType: 'delegation-loop', boundary: 'inter-agent', confidence: 0.95 };
+    }
+    return undefined;
+}
+function candidate(span, match) {
+    return {
+        ...match,
+        componentId: span.componentId,
+        spanId: span.spanId,
+    };
+}
+/** A transparent baseline limited to explicit runtime signals. */
+export const directSignalBaseline = {
+    id: 'direct-signal-v1',
+    diagnose(caseId, input) {
+        const candidates = input.structured.spans.flatMap((span) => {
+            const match = directSignal(span);
+            return match ? [candidate(span, match)] : [];
+        });
+        if (candidates.length > 0)
+            return diagnosed(caseId, candidates);
+        if (input.cleanReference && input.structured.spans.some((span) => {
+            const clean = input.cleanReference?.spans.find((item) => item.spanId === span.spanId);
+            return clean?.outputHash !== span.outputHash;
+        }))
+            return abstained(caseId, 'Output differs from reference but has no direct failure signal');
+        if (input.structured.spans.every(isHealthy))
+            return healthy(caseId);
+        return abstained(caseId, 'No qualified direct signal');
+    },
+};
+/**
+ * AQE reference-aware diagnosis. It adds paired-output comparison and a policy
+ * oracle to the direct-signal baseline; neither source is a hidden fault label.
+ */
+export const referenceAwareAqeDetector = {
+    id: 'aqe-reference-aware-v1',
+    diagnose(caseId, input) {
+        const direct = directSignalBaseline.diagnose(caseId, input);
+        if (direct.status === 'diagnosed')
+            return direct;
+        for (const span of input.structured.spans) {
+            if (span.kind === 'guardrail' && span.policyRef && span.expectedDecision && span.actualDecision
+                && span.expectedDecision !== span.actualDecision) {
+                return diagnosed(caseId, [candidate(span, {
+                        faultType: 'guardrail-bypass', boundary: 'guardrail', confidence: 1,
+                    })]);
+            }
+            if (span.kind === 'tool' && input.cleanReference) {
+                const clean = input.cleanReference.spans.find((item) => item.spanId === span.spanId);
+                if (clean && clean.outputHash !== span.outputHash) {
+                    return diagnosed(caseId, [candidate(span, {
+                            faultType: 'corrupted-tool-output', boundary: 'tool', confidence: 0.9,
+                        })]);
+                }
+            }
+        }
+        return direct;
+    },
+};
+/** Negative-control detector used to prove majority-class guessing cannot pass. */
+export const majorityFaultDetector = {
+    id: 'always-tool-unavailable',
+    diagnose(caseId, input) {
+        const span = input.structured.spans.find((item) => item.kind === 'tool') ?? input.structured.spans[0];
+        if (!span)
+            return { ...abstained(caseId, 'Empty trace'), status: 'parse-error' };
+        return diagnosed(caseId, [candidate(span, {
+                faultType: 'tool-unavailable', boundary: 'tool', confidence: 1,
+            })]);
+    },
+};
+function isHealthy(span) {
+    return span.status === 'ok'
+        && span.intendedDestination === span.actualDestination
+        && (!(span.expectedDecision && span.actualDecision) || span.expectedDecision === span.actualDecision)
+        && (span.retry ?? 0) < 3;
+}
+function diagnosed(caseId, candidates) {
+    return { caseId, status: 'diagnosed', candidates, signalObserved: true, latencyMs: 0 };
+}
+function healthy(caseId) {
+    return {
+        caseId,
+        status: 'diagnosed',
+        candidates: [{
+                faultType: 'none', boundary: 'control', componentId: 'workflow', spanId: 'run', confidence: 1,
+            }],
+        signalObserved: false,
+        latencyMs: 0,
+    };
+}
+function abstained(caseId, reason) {
+    return { caseId, status: 'abstained', candidates: [], signalObserved: false, latencyMs: 0, reason };
+}
+//# sourceMappingURL=detectors.js.map

package/dist/domains/chaos-resilience/diagnosis/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './corpus.js';
+export * from './detectors.js';
+export * from './scorer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domains/chaos-resilience/diagnosis/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './corpus.js';
+export * from './detectors.js';
+export * from './scorer.js';
+//# sourceMappingURL=index.js.map

package/dist/domains/chaos-resilience/diagnosis/scorer.d.ts

@@ -0,0 +1,8 @@
+import type { AgentFaultCorpus, AgentFaultDetector, AgentFaultScoreReport } from './types.js';
+export declare function scoreAgentFaultDetector(corpus: AgentFaultCorpus, detector: AgentFaultDetector, topK?: number): AgentFaultScoreReport;
+export interface AgentFaultQualification {
+    readonly passed: boolean;
+    readonly failures: readonly string[];
+}
+export declare function qualifyAgentFaultDetector(report: AgentFaultScoreReport): AgentFaultQualification;
+//# sourceMappingURL=scorer.d.ts.map