eval-quality 0.1.0 → 0.2.0

package/dist/core/compile/interface-inventory.d.ts

@@ -1,10 +1,32 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
 /** Rejects permitted interface kinds that this contract version cannot run. */
 export declare function checkInterfaceKind(contract: EvalContract): void;
+/**
+ * The transport identity AD-40 resolves a defect signature against: the method
+ * and the path template with parameter names erased, so `/notes/{id}` and
+ * `/notes/{noteId}` share one signature. Takes the two fields rather than an
+ * `Operation`, since AD-40's corpus-side signature declares the same pair and
+ * must produce the same string from it or the comparison is not a comparison.
+ */
+export declare function operationSignature(operation: {
+    readonly method: string;
+    readonly pathTemplate: string;
+}): string;
 /** Finds duplicate method and path signatures across the full inventory. */
 export declare function checkDuplicateOperationSignature(contract: EvalContract): void;
 /**
- * Checks each binding key against its operation's request shape.
+ * Checks each binding key against its operation's request shape, and each
+ * `{ principal }` value against the contract's declared principals.
  * Steps with unresolved operation IDs belong to a separate cross-field rule.
+ *
+ * The two conditions share one code and are not the same predicate: the key
+ * case is an input the contract did not declare, the principal case has a
+ * declared key whose referenced name the contract did not declare. AD-5's row
+ * is widened to say so. Placing the principal case here rather than in a root
+ * Zod refinement is deliberate: a constraint reaching from
+ * `interactionPlan[].inputBinding` into `testData.principals` cannot survive
+ * the export, and the published-schema differential sweep synthesises a
+ * `{ principal }` union-branch witness naming no declared principal, which a
+ * refinement would reject and ajv would accept.
  */
 export declare function checkUndeclaredMandatoryInput(contract: EvalContract): void;

package/dist/core/compile/interface-inventory.js

@@ -16,12 +16,22 @@ export function checkInterfaceKind(contract) {
 /** Erases parameter names so equivalent path templates share a signature. */
 const PARAMETER_SEGMENT_PATTERN = /\{[A-Za-z0-9_-]+\}/g;
 const erase = (pathTemplate) => pathTemplate.replace(PARAMETER_SEGMENT_PATTERN, '{}');
+/**
+ * The transport identity AD-40 resolves a defect signature against: the method
+ * and the path template with parameter names erased, so `/notes/{id}` and
+ * `/notes/{noteId}` share one signature. Takes the two fields rather than an
+ * `Operation`, since AD-40's corpus-side signature declares the same pair and
+ * must produce the same string from it or the comparison is not a comparison.
+ */
+export function operationSignature(operation) {
+    return `${operation.method} ${erase(operation.pathTemplate)}`;
+}
 /** Finds duplicate method and path signatures across the full inventory. */
 export function checkDuplicateOperationSignature(contract) {
     const seen = new Map();
     for (const iface of contract.permittedInterfaces) {
         for (const operation of iface.operations) {
-            const signature = `${operation.method} ${erase(operation.pathTemplate)}`;
+            const signature = operationSignature(operation);
             const collision = seen.get(signature);
             if (collision !== undefined) {
                 throw new StructuralFailure('duplicate-operation-signature', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].operations[operationId=${operation.operationId}]`, `collides with permittedInterfaces[logicalId=${collision.logicalId}].operations[operationId=${collision.operation.operationId}] after parameter-name erasure ("${signature}") (AD-19, AD-40)`);
@@ -31,11 +41,23 @@ export function checkDuplicateOperationSignature(contract) {
     }
 }
 /**
- * Checks each binding key against its operation's request shape.
+ * Checks each binding key against its operation's request shape, and each
+ * `{ principal }` value against the contract's declared principals.
  * Steps with unresolved operation IDs belong to a separate cross-field rule.
+ *
+ * The two conditions share one code and are not the same predicate: the key
+ * case is an input the contract did not declare, the principal case has a
+ * declared key whose referenced name the contract did not declare. AD-5's row
+ * is widened to say so. Placing the principal case here rather than in a root
+ * Zod refinement is deliberate: a constraint reaching from
+ * `interactionPlan[].inputBinding` into `testData.principals` cannot survive
+ * the export, and the published-schema differential sweep synthesises a
+ * `{ principal }` union-branch witness naming no declared principal, which a
+ * refinement would reject and ajv would accept.
  */
 export function checkUndeclaredMandatoryInput(contract) {
     const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
+    const principals = new Set(Object.keys(contract.testData.principals ?? {}));
     for (const step of contract.interactionPlan) {
         const operation = index.operationOf(step.operationId);
         if (operation === undefined)
@@ -46,8 +68,15 @@ export function checkUndeclaredMandatoryInput(contract) {
                 continue;
             const { requiredKeys, permittedKeys } = operation.requestShape[channel];
             for (const key of Object.keys(binding)) {
+                const path = `EvalContract.interactionPlan[stepId=${step.stepId}].inputBinding.${channel}[${JSON.stringify(key)}]`;
                 if (!requiredKeys.includes(key) && !permittedKeys.includes(key)) {
-                    throw new StructuralFailure('undeclared-mandatory-input', `EvalContract.interactionPlan[stepId=${step.stepId}].inputBinding.${channel}[${JSON.stringify(key)}]`, `operation "${operation.operationId}" declares "${key}" in neither requiredKeys nor permittedKeys of its ${channel} channel (AD-4)`);
+                    throw new StructuralFailure('undeclared-mandatory-input', path, `operation "${operation.operationId}" declares "${key}" in neither requiredKeys nor permittedKeys of its ${channel} channel (AD-4)`);
+                }
+                const value = binding[key];
+                if (value !== undefined &&
+                    'principal' in value &&
+                    !principals.has(value.principal)) {
+                    throw new StructuralFailure('undeclared-mandatory-input', path, `binds the principal "${value.principal}", which testData.principals does not declare (AD-4, AD-19)`);
                 }
             }
         }

package/dist/core/compile/reachability.d.ts

@@ -1,6 +1,19 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
+import type { Expression } from '../schemas/expression.ts';
+import type { Operation } from '../schemas/interface.ts';
 import { type PlanIndex } from '../seal/plan-index.ts';
 export declare function checkBoundElementScope(contract: EvalContract): void;
+/** `checkBoundElementScope` over one bare `Expression`. */
+export declare function checkExpressionBoundElementScope(expression: Expression, artifactPath: string): void;
+/**
+ * Visits every `{ pointer }` operand of one bare `Expression`, which a
+ * probe-side legality pass needs for the rules a contract has no equivalent of:
+ * that every pointer roots at the reserved step identifier, and which evidence
+ * channels the condition actually names.
+ */
+export declare function forEachExpressionPointer(expression: Expression, visit: (pointer: string, path: string) => void): void;
+/** `checkEvidenceReachability` over one bare `Expression` and one operation. */
+export declare function checkExpressionEvidenceReachability(expression: Expression, artifactPath: string, operation: Operation): void;
 type ReachabilityResult = {
     readonly reachable: true;
 } | {
@@ -9,7 +22,11 @@ type ReachabilityResult = {
 };
 /**
  * Non-throwing core that `checkEvidenceReachability` wraps; also called
- * directly by tests.
+ * directly by tests. The two lines below are the whole of what ties this to a
+ * declared interaction plan; everything past them reads the operation alone,
+ * which is what `evaluateReachabilityAgainstOperation` exposes for a probe-side
+ * condition, whose one step identifier is reserved and resolves to the
+ * signature's home operation with no plan in sight.
  */
 export declare function evaluatePointerReachability(pointer: string, index: PlanIndex): ReachabilityResult;
 /** `unreachable-check-evidence`: an interaction-rooted pointer the declared interfaces cannot produce. */

package/dist/core/compile/reachability.js

@@ -60,6 +60,34 @@ export function checkBoundElementScope(contract) {
         }
     });
 }
+/** `checkBoundElementScope` over one bare `Expression`. */
+export function checkExpressionBoundElementScope(expression, artifactPath) {
+    visitExpression(expression, '', false, (site) => {
+        if (site.pointer.startsWith('@') && !site.insideQuantifier) {
+            throw new StructuralFailure('malformed-operator-expression', `${artifactPath}${site.path}`, `bound-element pointer "${site.pointer}" appears outside any quantifier's predicate; "@/" binds only inside a quantifier (AD-26)`);
+        }
+    });
+}
+/**
+ * Visits every `{ pointer }` operand of one bare `Expression`, which a
+ * probe-side legality pass needs for the rules a contract has no equivalent of:
+ * that every pointer roots at the reserved step identifier, and which evidence
+ * channels the condition actually names.
+ */
+export function forEachExpressionPointer(expression, visit) {
+    visitExpression(expression, '', false, (site) => {
+        visit(site.pointer, site.path);
+    });
+}
+/** `checkEvidenceReachability` over one bare `Expression` and one operation. */
+export function checkExpressionEvidenceReachability(expression, artifactPath, operation) {
+    visitExpression(expression, '', false, (site) => {
+        const result = evaluateReachabilityAgainstOperation(site.pointer, operation);
+        if (!result.reachable) {
+            throw new StructuralFailure('unreachable-check-evidence', `${artifactPath}${site.path}`, `"${site.pointer}" ${result.reason}`);
+        }
+    });
+}
 const reachable = () => ({ reachable: true });
 const unreachable = (reason) => ({
     reachable: false,
@@ -81,7 +109,11 @@ function descendsIntoDeclaredScalar(types, tail, firstToken) {
 }
 /**
  * Non-throwing core that `checkEvidenceReachability` wraps; also called
- * directly by tests.
+ * directly by tests. The two lines below are the whole of what ties this to a
+ * declared interaction plan; everything past them reads the operation alone,
+ * which is what `evaluateReachabilityAgainstOperation` exposes for a probe-side
+ * condition, whose one step identifier is reserved and resolves to the
+ * signature's home operation with no plan in sight.
  */
 export function evaluatePointerReachability(pointer, index) {
     // A `@/` pointer is relative to a bound element. Nothing declared to
@@ -97,6 +129,19 @@ export function evaluatePointerReachability(pointer, index) {
     if (operation === undefined) {
         return unreachable(`names step "${target.stepId}", which names operation "${step.operationId}", not declared by any permitted interface`);
     }
+    return evaluateReachabilityAgainstOperation(pointer, operation);
+}
+/**
+ * The same rules, against an operation the caller already resolved. Without
+ * this check a probe-side condition addressing an undeclared channel or key
+ * resolves absent, every comparison over it resolves `false`, and the probe
+ * reports its defect as never triggered — a silently passing run on a signature
+ * that was never writable.
+ */
+function evaluateReachabilityAgainstOperation(pointer, operation) {
+    if (pointer.startsWith('@'))
+        return reachable();
+    const target = parseEvidenceTarget(pointer);
     if (target.channel === 'stdout' || target.channel === 'stderr') {
         // stdout/stderr are always bare strings. A non-empty tail proves the
         // pointer unreachable.

package/dist/core/compile/sensitivity-witness.d.ts

@@ -4,7 +4,7 @@
  * execute it, and that its leg identifiers are distinct from each other and
  * from every interaction-plan step.
  *
- * No new AD-5 code is minted. The registry is closed at twenty-one and
+ * No new AD-5 code is minted. The registry is closed at twenty-three and
  * `check:ad5-registry` pins it against the spine, so each defect below takes the
  * code that already names it. Two rows stretch that reading: a leg-id equality
  * and a leg-id/step-id collision are identifier collisions, and

package/dist/core/compile/sensitivity-witness.js

@@ -4,7 +4,7 @@
  * execute it, and that its leg identifiers are distinct from each other and
  * from every interaction-plan step.
  *
- * No new AD-5 code is minted. The registry is closed at twenty-one and
+ * No new AD-5 code is minted. The registry is closed at twenty-three and
  * `check:ad5-registry` pins it against the spine, so each defect below takes the
  * code that already names it. Two rows stretch that reading: a leg-id equality
  * and a leg-id/step-id collision are identifier collisions, and

package/dist/core/emit/emit.d.ts

@@ -0,0 +1,9 @@
+import type { ScoredOutcomesAndVerdict } from '../score/score.ts';
+import type { EmitStage } from '../stage-contracts.ts';
+/**
+ * The stage. Builds `scoringVersionInputs`/`scoringVersion`/
+ * `comparabilityKey`/the strength block/the remediation block once, shared
+ * between the two mode branches, then the mode-discriminated artifact
+ * literal, then calls `checkModeAgreement` immediately before returning.
+ */
+export declare const emit: EmitStage<ScoredOutcomesAndVerdict>;

package/dist/core/emit/emit.js

@@ -0,0 +1,214 @@
+/**
+ * AD-24's emit stage: `score`'s widened product plus the three caller-
+ * attested digests AD-11 fixes, minting the `EvidenceArtifact` this package
+ * has never built until now. Pure per AD-1/AD-2, and total the way every
+ * other stage in this package is: nothing here throws for a domain input.
+ *
+ * `comparabilityKey`, `strength`, and `remediation` are lifted verbatim from
+ * `scripts/worked-example-target.ts`'s own hand-assembly (its former
+ * lines 1432-1487), the field-by-field precedent this module generalises
+ * from one caller-assembled record to `score`'s own widened product.
+ */
+import { digestArtifact } from '../canonical/digest.js';
+import { freezeArtifact } from '../lineage/freeze.js';
+import { EvidenceArtifact, } from '../schemas/evidence-artifact.js';
+import { checkModeAgreement } from '../score/mode-agreement.js';
+import { buildStrengthVector } from '../score/strength.js';
+const SCORING_POLICY_ARTIFACT_PATH = 'ScoringPolicy';
+const SCORING_VERSION_INPUTS_ARTIFACT_PATH = 'ScoringVersionInputs';
+const COMPARABILITY_KEY_ARTIFACT_PATH = 'ComparabilityKey';
+/**
+ * `mode` joins AD-11's three caller-attested digest names as a fourth
+ * member: like them, it has no artifact source anywhere in this pipeline and
+ * can only ever be caller-supplied, never re-derived by `score`.
+ */
+const CALLER_ATTESTED_INPUTS = ['corpusDigest', 'fixtureDigest', 'evaluatorConfigurationDigest', 'mode'];
+/**
+ * The stage. Builds `scoringVersionInputs`/`scoringVersion`/
+ * `comparabilityKey`/the strength block/the remediation block once, shared
+ * between the two mode branches, then the mode-discriminated artifact
+ * literal, then calls `checkModeAgreement` immediately before returning.
+ */
+export const emit = (scored, corpusDigest, fixtureDigest, evaluatorConfigurationDigest) => {
+    const scoringPolicyDigest = digestArtifact(scored.policy, SCORING_POLICY_ARTIFACT_PATH);
+    // AD-7's declared key: the scoring policy digest plus the corpus digest
+    // restricted to the probes both results cover -- here, the admitted probe
+    // identifiers, sorted so array order never enters the digest.
+    const comparabilityKey = digestArtifact({
+        scoringPolicyDigest,
+        probeIds: scored.sealedProbes.admitted
+            .map((entry) => entry.probe.probeId)
+            .sort(),
+    }, COMPARABILITY_KEY_ARTIFACT_PATH);
+    const excludedProbeIds = scored.sealedProbes.rejected.map((entry) => entry.probe.probeId);
+    const { trials, outcomes: scoredOutcomes } = scored.assessment.outcomeState;
+    const trialCount = `${trials.completed} completed trial${trials.completed === 1 ? '' : 's'}`;
+    const unreachedOracles = scoredOutcomes.filter((outcome) => outcome.resolution.state === 'unreached');
+    // AD-21: a run that resolved `unreached` or completed fewer trials than
+    // the policy's declared minimum marks the vector non-comparable rather
+    // than silently comparing it.
+    const comparable = trials.completed >= trials.declaredMinimum && unreachedOracles.length === 0;
+    const strengthNote = [
+        `${scored.sealedProbes.admitted.length} admitted probe over ${trialCount}.`,
+        trials.completed < trials.declaredMinimum
+            ? `Below the declared minimum of ${trials.declaredMinimum}.`
+            : null,
+        unreachedOracles.length > 0
+            ? `${unreachedOracles.map((outcome) => outcome.oracleId).join(', ')} resolved unreached.`
+            : null,
+        comparable ? null : 'The vector is reported and marked non-comparable.',
+    ]
+        .filter((part) => part !== null)
+        .join(' ');
+    const vector = buildStrengthVector(scored.sealedProbes.admitted, new Map([[scored.probe.probeId, scored.trialSetResult]]));
+    // `scored.ladder.verdict` is `Verdict | null`: `null` is AD-21's Invalid
+    // rung, which "never becomes a contract verdict" -- a run reaching that
+    // rung is the caller's own signal to stop before minting an artifact at
+    // all, exactly as `scripts/worked-example-target.ts`'s own
+    // `if (ladder.verdict === null) fail(...)` guard, immediately before its
+    // call into this stage, already enforces. `emit` throws nothing for a
+    // domain input (the one throw this stage carries is the mode-agreement
+    // check below), so a verdict-less ladder reaching this point is a
+    // precondition violation the same way `seal()`'s own null-direction
+    // guard is one call earlier in the pipeline: trusted rather than
+    // re-checked a second time.
+    const verdict = scored.ladder.verdict;
+    const commonFields = {
+        schemaVersion: 3,
+        parentDigest: null,
+        // v0 mints no revision path for an evidence artifact: every `emit`
+        // call is a lineage root, matching `seal.ts`'s own root-artifact
+        // precedent for the one other `lineage: 'mints'` stage with a built
+        // module.
+        revisionCount: 0,
+        runId: scored.runId,
+        comparabilityKey,
+        excludedProbeIds,
+        exitCode: scored.ladder.exitCode,
+        verdictBasis: [...scored.ladder.basis],
+        callerAttestedInputs: [...CALLER_ATTESTED_INPUTS],
+        trials,
+        outcomes: [...scored.outcomes],
+        uncitedFindings: [...scored.uncitedFindings],
+        coverageGaps: [...scored.assessment.coverageGaps],
+        strength: {
+            denominator: `unique qualified probe identifiers exercised per class, across ${trialCount}`,
+            // `matchProbeWitness` is the only reachable producer of a
+            // `Strength.basis` value and it always returns `'measured'`;
+            // `'reconstructed'`'s one producer is dead code in v0. No live
+            // second value to select between, so this is a constant.
+            basis: 'measured',
+            vector,
+            comparable,
+            note: strengthNote,
+        },
+        remediation: {
+            // AD-12's REMEDIATION count, distinct from this artifact's own root
+            // `revisionCount` above; the two are named identically only because
+            // they nest at different depths.
+            revisionCount: scored.contract.revisionCount,
+            cap: scored.policy.remediationCap,
+            // AD-12 has the package only validate the cap; nothing enforces it,
+            // so there is no second legal value.
+            capSource: 'caller-attested',
+            // `remediationState` is already declared `LineageChain` (`ladder.ts`):
+            // reused from the assessment, never recomputed here.
+            lineageChain: scored.assessment.remediationState,
+        },
+    };
+    /**
+     * Runs both of this stage's checks, then freezes and returns. AD-29: a
+     * stage freezes the artifact it owns, matching `seal.ts`/
+     * `preflight/reduce.ts`'s own precedent for the other two minting stages.
+     * Both checks fire only on a precondition violation, never a domain
+     * input: neither is reachable through any path this module's own
+     * construction takes.
+     */
+    const finalize = (artifact) => {
+        const agreement = checkModeAgreement({ mode: scored.assessment.mode }, { mode: artifact.mode });
+        if (!agreement.agrees) {
+            // Reachable only through a type-system bypass: `artifact.mode` is
+            // stamped from `scored.assessment.mode` two lines above in every
+            // branch this function builds, so the two can disagree only if a
+            // caller assembled `scored` from two independently-sourced values
+            // -- the future caller this check exists for, mirroring
+            // `reduceTrialSet`'s own `TypeError`-for-bypass-only-input
+            // precedent.
+            throw new TypeError(`emit(): assembled an artifact whose mode ("${agreement.artifactMode}") disagrees with the assessment mode ("${agreement.recordMode}") it was built from`);
+        }
+        return freezeArtifact(validateAssembledArtifact(artifact));
+    };
+    if (scored.assessment.mode === 'production') {
+        const scoringVersionInputs = {
+            contractSchemaVersion: scored.contract.schemaVersion,
+            corpusDigest,
+            fixtureDigest,
+            evaluatorConfigurationDigest,
+            scoringPolicyDigest,
+            mode: 'production',
+        };
+        const artifact = {
+            ...commonFields,
+            mode: 'production',
+            scoringVersionInputs,
+            scoringVersion: digestArtifact(scoringVersionInputs, SCORING_VERSION_INPUTS_ARTIFACT_PATH),
+            productionVerdict: verdict,
+        };
+        return finalize(artifact);
+    }
+    const scoringVersionInputs = {
+        contractSchemaVersion: scored.contract.schemaVersion,
+        corpusDigest,
+        fixtureDigest,
+        evaluatorConfigurationDigest,
+        scoringPolicyDigest,
+        mode: 'contract-scoring',
+    };
+    const artifact = {
+        ...commonFields,
+        mode: 'contract-scoring',
+        scoringVersionInputs,
+        scoringVersion: digestArtifact(scoringVersionInputs, SCORING_VERSION_INPUTS_ARTIFACT_PATH),
+        contractVerdict: verdict,
+        uncitedFindingGaps: [...scored.assessment.uncitedDefectFindings],
+        systemRecommendationRecorded: scored.assessment.systemRecommendationRecorded,
+        systemRecommendationNote: scored.assessment.systemRecommendationNote,
+    };
+    return finalize(artifact);
+};
+/**
+ * The runtime backstop `finalize()` calls before freezing: TypeScript
+ * guarantees this module's own object literals match `EvidenceArtifact`'s
+ * shape at compile time, except at the one place that casts past it
+ * (`scored.ladder.verdict as Verdict`, above). Mirrors `seal.ts`'s own
+ * `validateAssembledBrief` -- same `safeParse`-then-`TypeError` shape, same
+ * first-issue diagnosis -- so a verdict that reached this function `null`
+ * despite the caller's own precondition fails loudly here instead of
+ * shipping a schema-invalid artifact silently.
+ */
+function validateAssembledArtifact(artifact) {
+    const result = EvidenceArtifact.safeParse(artifact);
+    if (result.success)
+        return result.data;
+    const issueCount = result.error.issues.length;
+    const firstIssue = result.error.issues[0];
+    const firstPath = firstIssue ? dotPath(firstIssue.path) : '';
+    throw new TypeError(`emit(): assembled an artifact that failed EvidenceArtifact validation: ${issueCount} issue${issueCount === 1 ? '' : 's'}, first at "${firstPath === '' ? '(root)' : firstPath}"`, { cause: result.error });
+}
+/** `seal.ts`'s own formatter, duplicated rather than shared: both are small, stage-local, and neither exports it today. */
+function dotPath(path) {
+    const segments = [];
+    for (const segment of path) {
+        if (typeof segment === 'number')
+            segments.push(`[${segment}]`);
+        else if (typeof segment === 'symbol' || /[^\w$]/.test(segment)) {
+            segments.push(`[${JSON.stringify(String(segment))}]`);
+        }
+        else {
+            if (segments.length > 0)
+                segments.push('.');
+            segments.push(segment);
+        }
+    }
+    return segments.join('');
+}

package/dist/core/emit/private-artifact-digest.d.ts

@@ -0,0 +1,11 @@
+import type { PrivateArtifactManifest } from '../schemas/private-artifact-manifest.ts';
+/**
+ * Throws `RuntimeFault('digest-mismatch', ...)` on the first
+ * `entries[i]` whose declared `digest` disagrees with
+ * `resolvedDigests.get(entry.privateRef)`. An entry with no resolved digest
+ * at all -- `resolvedDigests` carries no key for its `privateRef` -- is the
+ * same disagreement: there is no byte the manifest's declared digest can be
+ * checked against, which this comparator treats no differently from a
+ * genuine mismatch.
+ */
+export declare function checkPrivateArtifactManifestDigests(manifest: PrivateArtifactManifest, resolvedDigests: ReadonlyMap<string, string>): void;

package/dist/core/emit/private-artifact-digest.js

@@ -0,0 +1,31 @@
+/**
+ * The pure half of `private-artifact-manifest.ts`'s own "a mismatch is an
+ * AD-28 `digest-mismatch` fault": given a manifest and each entry's already-
+ * resolved digest, throws on the first disagreement. AD-8 requires the
+ * digest recomputed from the resolved bytes; resolving those bytes needs
+ * `CorpusPort.resolve`, an async port method, and AD-34 makes awaiting a
+ * port `application/`'s job, never `core/`'s. This module is the comparator
+ * alone and has no caller yet: whoever first awaits `CorpusPort.resolve` to
+ * build `resolvedDigests` is this function's caller, and that await belongs
+ * in `application/`, not here.
+ */
+import { RuntimeFault } from '../schemas/faults.js';
+/**
+ * Throws `RuntimeFault('digest-mismatch', ...)` on the first
+ * `entries[i]` whose declared `digest` disagrees with
+ * `resolvedDigests.get(entry.privateRef)`. An entry with no resolved digest
+ * at all -- `resolvedDigests` carries no key for its `privateRef` -- is the
+ * same disagreement: there is no byte the manifest's declared digest can be
+ * checked against, which this comparator treats no differently from a
+ * genuine mismatch.
+ */
+export function checkPrivateArtifactManifestDigests(manifest, resolvedDigests) {
+    manifest.entries.forEach((entry, index) => {
+        const resolved = resolvedDigests.get(entry.privateRef);
+        if (resolved === entry.digest)
+            return;
+        throw new RuntimeFault('digest-mismatch', `PrivateArtifactManifest.entries[${index}]`, `entry privateRef "${entry.privateRef}" declares digest "${entry.digest}", but the resolved bytes digest to ${resolved === undefined
+            ? 'nothing (no resolved digest supplied for this privateRef)'
+            : `"${resolved}"`}`);
+    });
+}

package/dist/core/evaluate/evidence-resolution.d.ts

@@ -8,7 +8,7 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
 import type { JsonValue } from '../schemas/primitives.ts';
 import type { Observation } from '../schemas/sealed-run-record.ts';
-import { type PlanIndex } from '../seal/plan-index.ts';
+import { type EvidenceTarget, type PlanIndex } from '../seal/plan-index.ts';
 import type { PointerDenotesCollection, ResolveOperand } from './resolution.ts';
 import { type ResolvedValue } from './resolved-value.ts';
 /**
@@ -34,6 +34,16 @@ export declare function walkTail(root: JsonValue, tail: readonly string[]): Reso
  * calling it.
  */
 export declare function decodeBoundElementTail(pointer: string): readonly string[];
+/**
+ * Selects the channel `target` names off one `Observation`. `stdout`/`stderr`
+ * can carry a tail even though they're bare strings; `walkTail` already
+ * resolves any non-empty tail against a string to `ABSENT`, so no special
+ * case is needed here.
+ *
+ * Exported so `core/score/bindings.ts` reads a captured pointer's channel off
+ * an observation through this one spelling, keeping the switch in one place.
+ */
+export declare function channelRoot(observation: Observation, target: EvidenceTarget): JsonValue;
 /**
  * The `ResolveOperand`. `stepObservations` holds one already-selected
  * `Observation` per interaction step; `referenceSets` mirrors the contract's

package/dist/core/evaluate/evidence-resolution.js

@@ -57,8 +57,11 @@ export function decodeBoundElementTail(pointer) {
  * can carry a tail even though they're bare strings; `walkTail` already
  * resolves any non-empty tail against a string to `ABSENT`, so no special
  * case is needed here.
+ *
+ * Exported so `core/score/bindings.ts` reads a captured pointer's channel off
+ * an observation through this one spelling, keeping the switch in one place.
  */
-function channelRoot(observation, target) {
+export function channelRoot(observation, target) {
     switch (target.channel) {
         case 'response-body':
             return observation.responseBody;

package/dist/core/failure-codes.d.ts

@@ -1,5 +1,5 @@
-/** AD-5's twenty-one compile-time failure codes, as data, in the table's order. */
-export declare const FAILURE_CODES: readonly ['missing-requirement-linkage', 'no-observable-success-criterion', 'unreachable-check-evidence', 'malformed-operator-expression', 'quantifier-over-non-collection', 'quantifier-nesting-exceeded', 'unresolved-reference-set', 'duplicate-operation-signature', 'undeclared-mandatory-input', 'oracle-missing-channel', 'direction-check-misaligned', 'unsupported-interface-kind', 'nested-temporal-clause', 'plan-exceeds-scripting-bound', 'rubric-scores-reasoning-prose', 'rubric-unanchored', 'rubric-evidence-unreachable', 'forbidden-input-floor-incomplete', 'scoped-reference-resolves-forbidden', 'waiver-incomplete', 'brief-exceeds-scripting-bound'];
+/** AD-5's twenty-three compile-time failure codes, as data, in the table's order. */
+export declare const FAILURE_CODES: readonly ['missing-requirement-linkage', 'no-observable-success-criterion', 'unreachable-check-evidence', 'malformed-operator-expression', 'quantifier-over-non-collection', 'quantifier-nesting-exceeded', 'unresolved-reference-set', 'duplicate-operation-signature', 'undeclared-mandatory-input', 'oracle-missing-channel', 'direction-check-misaligned', 'unsupported-interface-kind', 'nested-temporal-clause', 'plan-exceeds-scripting-bound', 'binding-cycle', 'captured-channel-undeclared', 'rubric-scores-reasoning-prose', 'rubric-unanchored', 'rubric-evidence-unreachable', 'forbidden-input-floor-incomplete', 'scoped-reference-resolves-forbidden', 'waiver-incomplete', 'brief-exceeds-scripting-bound'];
 export type FailureCode = (typeof FAILURE_CODES)[number];
 /**
  * AD-5's compile-time failure registry: thrown when a structural error fails

package/dist/core/failure-codes.js

@@ -1,11 +1,11 @@
-/** AD-5's twenty-one compile-time failure codes, as data, in the table's order. */
+/** AD-5's twenty-three compile-time failure codes, as data, in the table's order. */
 // This lives in `core/`, since it's a plain data tuple and `core/schemas/`
 // is reserved for Zod definitions. The compiler that emits these codes lives
 // in `core/compile/`, one directory over.
 //
 // `scripts/check-ad5-registry.ts` checks this tuple against AD-5's own
 // registry table under `npm run validate`; the tuple's own invariants
-// (twenty-one members, unique, kebab-case) are locked in
+// (twenty-three members, unique, kebab-case) are locked in
 // tests/schemas/failure-codes.test.ts.
 export const FAILURE_CODES = [
     'missing-requirement-linkage',
@@ -22,6 +22,8 @@ export const FAILURE_CODES = [
     'unsupported-interface-kind',
     'nested-temporal-clause',
     'plan-exceeds-scripting-bound',
+    'binding-cycle',
+    'captured-channel-undeclared',
     'rubric-scores-reasoning-prose',
     'rubric-unanchored',
     'rubric-evidence-unreachable',