eval-quality 0.1.0 → 0.3.0

package/dist/core/compile/expression-legality.js

@@ -3,11 +3,18 @@
  * reference-set resolution. Each check reports the first structural failure.
  */
 import { digestArtifact } from '../canonical/digest.js';
+import { targetsDescribedChannel } from '../declared-inputs.js';
 import { StructuralFailure } from '../failure-codes.js';
+import { operationsOf } from '../schemas/interface.js';
 import { JsonTypeName } from '../schemas/primitives.js';
-import { buildPlanIndex, parseEvidenceTarget, } from '../seal/plan-index.js';
+import { anyOperationOf, buildPlanIndex, parseEvidenceTarget, } from '../seal/plan-index.js';
 import { substitutePointer } from './oracle-alignment.js';
-function walkExpression(expr, quantifierDepth, path, visitor) {
+/**
+ * The one expression walker in this package. Contract-free and a superset of
+ * the narrower walks the checks below need, so a probe-side legality pass
+ * reuses it rather than adding a fifth traversal that can drift from it.
+ */
+export function walkExpression(expr, quantifierDepth, path, visitor) {
     switch (expr.op) {
         case 'not':
             walkExpression(expr.operands[0], quantifierDepth, `${path}.operands[0]`, visitor);
@@ -63,7 +70,7 @@ function forEachContractExpression(contract, visit) {
         });
     });
     contract.permittedInterfaces.forEach((iface, interfaceIndex) => {
-        iface.operations.forEach((operation, operationIndex) => {
+        operationsOf(iface).forEach((operation, operationIndex) => {
             const witness = operation.sensitivityWitness;
             if (witness === null)
                 return;
@@ -116,41 +123,129 @@ const OPERAND_LEGALITY = {
 const artifactKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)
     ? `.${key}`
     : `[${JSON.stringify(key)}]`;
+/**
+ * One operand's two position rules: the `OPERAND_LEGALITY` table, and the
+ * `ordering`-over-`call-inputs` rule that sits beside it. Both are decidable
+ * from the operand alone, so both cross over to a bare `Expression`.
+ */
+function checkOperandAtPosition(operand, op, position, artifactPath) {
+    const legal = OPERAND_LEGALITY[op]?.[String(position)];
+    if (legal === undefined)
+        return;
+    const kind = kindOf(operand);
+    if (!legal.has(kind)) {
+        throw new StructuralFailure('malformed-operator-expression', artifactPath, `"${op}" does not accept a ${kind} operand at position ${position} (AD-4, AD-26)`);
+    }
+    if (op === 'ordering' &&
+        'pointer' in operand &&
+        !operand.pointer.startsWith('@') &&
+        parseEvidenceTarget(operand.pointer).channel === 'call-inputs') {
+        throw new StructuralFailure('malformed-operator-expression', artifactPath, '"ordering" accepts observed output only, never call-inputs (AD-4)');
+    }
+}
+/**
+ * `checkOperandLegality` over one bare `Expression`, minus the `covers-by-key`
+ * `expectedKey` uniqueness rule, which reads the contract's declared reference
+ * sets and has no probe-side form: a probe-side condition may carry no
+ * `{ referenceSet }` operand at all.
+ */
+export function checkExpressionOperandLegality(expression, artifactPath) {
+    walkExpression(expression, 0, '', {
+        onOperand: (operand, op, position, path) => {
+            checkOperandAtPosition(operand, op, position, `${artifactPath}${path}`);
+        },
+    });
+}
+/** `checkRegexConstructs` over one bare `Expression`. */
+export function checkExpressionRegexConstructs(expression, artifactPath) {
+    walkExpression(expression, 0, '', {
+        onRegex: (pattern, path) => {
+            const rejection = regexRejection(pattern);
+            if (rejection !== null) {
+                throw new StructuralFailure('malformed-operator-expression', `${artifactPath}${path}.pattern`, `regex pattern "${pattern}" ${rejection}, a rejected construct (AD-4)`);
+            }
+        },
+    });
+}
+/** `checkQuantifierNesting` over one bare `Expression`. */
+export function checkExpressionQuantifierNesting(expression, artifactPath) {
+    walkExpression(expression, 0, '', {
+        onQuantifier: (_expr, path, quantifierDepth) => {
+            if (quantifierDepth >= 1) {
+                throw new StructuralFailure('quantifier-nesting-exceeded', `${artifactPath}${path}`, "a quantifier appears inside another quantifier's predicate; quantifiers may not nest more than one level (AD-4)");
+            }
+        },
+        onCoversByKey: (_expr, path, quantifierDepth) => {
+            if (quantifierDepth >= 1) {
+                throw new StructuralFailure('quantifier-nesting-exceeded', `${artifactPath}${path}`, "covers-by-key appears inside a quantifier's predicate, where it may never nest (AD-4)");
+            }
+        },
+    });
+}
+/**
+ * The declaration a reference-set operand names, and `undefined` when the
+ * contract declares none by that identifier. An undeclared identifier is
+ * `checkReferenceSetResolution`'s `unresolved-reference-set`, so the
+ * shape-aware checks below stay quiet about it.
+ */
+function declaredReferenceSetOf(contract, referenceSetId) {
+    const declarations = contract.referenceSets;
+    if (declarations === null || !Object.hasOwn(declarations, referenceSetId)) {
+        return undefined;
+    }
+    return declarations[referenceSetId];
+}
 /** Checks each operator's operands against its position-specific constraints. */
 export function checkOperandLegality(contract) {
     forEachContractExpression(contract, (site) => {
         walkExpression(site.expression, 0, '', {
             onOperand: (operand, op, position, path) => {
-                const legal = OPERAND_LEGALITY[op]?.[String(position)];
-                if (legal === undefined)
+                checkOperandAtPosition(operand, op, position, `${site.artifactPath}${path}`);
+            },
+            // Fires only for `set-membership`'s set position, which is the one
+            // position that reads a reference set by its single declared key
+            // (`reference-set.ts`). `keys` is `.min(1)` with no maximum, so a
+            // two-key set names no one key to read there, and a member missing
+            // the declared key has nothing to read at all. AD-26 assigns
+            // `malformed-operator-expression` to an operand type the operator
+            // does not accept, which is what each of those is. Rejecting them
+            // here is what makes the resolver's projection total.
+            onSetOperand: (setOperand, path) => {
+                if (!('referenceSet' in setOperand))
+                    return;
+                const { referenceSet } = setOperand;
+                const declaration = declaredReferenceSetOf(contract, referenceSet);
+                if (declaration === undefined)
                     return;
-                const kind = kindOf(operand);
-                if (!legal.has(kind)) {
-                    throw new StructuralFailure('malformed-operator-expression', `${site.artifactPath}${path}`, `"${op}" does not accept a ${kind} operand at position ${position} (AD-4, AD-26)`);
+                if (declaration.keys.length !== 1) {
+                    throw new StructuralFailure('malformed-operator-expression', `${site.artifactPath}${path}`, `referenceSet "${referenceSet}" declares ${declaration.keys.length} keys, and set-membership reads exactly one, so only a single-key set is legal in its set position (AD-4, AD-26)`);
                 }
-                if (op === 'ordering' &&
-                    'pointer' in operand &&
-                    !operand.pointer.startsWith('@') &&
-                    parseEvidenceTarget(operand.pointer).channel === 'call-inputs') {
-                    throw new StructuralFailure('malformed-operator-expression', `${site.artifactPath}${path}`, '"ordering" accepts observed output only, never call-inputs (AD-4)');
+                const key = declaration.keys[0];
+                for (const [index, member] of declaration.members.entries()) {
+                    if (Object.hasOwn(member, key))
+                        continue;
+                    throw new StructuralFailure('malformed-operator-expression', `EvalContract.referenceSets[id=${referenceSet}].members[${index}]${artifactKey(key)}`, `referenceSet "${referenceSet}" has a member carrying no key "${key}", which it declares and which set-membership reads (AD-4, AD-26)`);
                 }
             },
             onCoversByKey: (expr) => {
                 const expected = expr.operands[0];
                 if (!('referenceSet' in expected))
                     return;
-                const declarations = contract.referenceSets;
-                if (declarations === null ||
-                    !Object.hasOwn(declarations, expected.referenceSet))
-                    return;
-                const declaration = declarations[expected.referenceSet];
+                const declaration = declaredReferenceSetOf(contract, expected.referenceSet);
                 if (declaration === undefined)
                     return;
                 const seen = new Set();
                 for (const [index, member] of declaration.members.entries()) {
-                    if (!Object.hasOwn(member, expr.expectedKey))
-                        continue;
                     const memberPath = `EvalContract.referenceSets[id=${expected.referenceSet}].members[${index}]${artifactKey(expr.expectedKey)}`;
+                    // `coversByKey` returns false for the whole collection when one
+                    // declared member lacks `expectedKey`, which reads as a detected
+                    // defect in the system under test, when it is an authoring
+                    // mistake. This check used to walk past that member to keep the
+                    // duplicate-detection loop total, which left the compiler silent
+                    // about the one shape that makes the operator answer wrongly.
+                    if (!Object.hasOwn(member, expr.expectedKey)) {
+                        throw new StructuralFailure('malformed-operator-expression', memberPath, `referenceSet "${expected.referenceSet}" has a member carrying no expectedKey "${expr.expectedKey}", which covers-by-key reads on every member (AD-4)`);
+                    }
                     const digest = digestArtifact(member[expr.expectedKey], memberPath);
                     if (seen.has(digest)) {
                         throw new StructuralFailure('malformed-operator-expression', memberPath, `referenceSet "${expected.referenceSet}" repeats expectedKey "${expr.expectedKey}" for covers-by-key (AD-4)`);
@@ -280,6 +375,47 @@ function forEachQuantifierCollection(expr, boundElementRoot, path, visit) {
             return;
     }
 }
+/**
+ * The check itself, against whatever resolves a step identifier to the
+ * operation that answers it. The contract path resolves through the plan index
+ * or the witness scope; a probe-side condition resolves the one reserved step
+ * identifier to the signature's home operation.
+ */
+function checkQuantifiersAgainst(expression, artifactPath, operationFor) {
+    forEachQuantifierCollection(expression, null, '', (pointer, path) => {
+        const target = parseEvidenceTarget(pointer);
+        const operation = operationFor(target.stepId);
+        if (operation === undefined)
+            return;
+        // The operation is resolved before the target is tested, because which
+        // channel carries the declared structure is the operation's own answer,
+        // and on the artifact channel so is which file.
+        if (!targetsDescribedChannel(operation, target))
+            return;
+        const firstToken = target.tail.length === 1 ? target.tail[0] : undefined;
+        const declaredType = firstToken === undefined
+            ? undefined
+            : operation.responseDescriptor.types[firstToken];
+        if (declaredType !== undefined &&
+            declaredType !== null &&
+            NON_COLLECTION_TYPES.has(declaredType)) {
+            throw new StructuralFailure('quantifier-over-non-collection', `${artifactPath}${path}`, `"${pointer}" is declared "${declaredType}" by operation "${operation.operationId}", not a collection (AD-4)`);
+        }
+    });
+}
+/**
+ * `checkQuantifierOverNonCollection` over one bare `Expression` rooted at a
+ * known set of step identifiers, all of which resolve to one operation. The
+ * `legIds` argument is load-bearing: omit it and the check silently no-ops on
+ * every expression, which is the trap the witness branch below already warns
+ * about. It reads the operation's declared response types, never its
+ * `collectionLocations`; a declared non-array type beats a contradictory
+ * collection location, and a re-derivation that read the other field would
+ * disagree with the compiler on a committed fixture.
+ */
+export function checkExpressionQuantifierOverNonCollection(expression, artifactPath, scope) {
+    checkQuantifiersAgainst(expression, artifactPath, (stepId) => scope.legIds.includes(stepId) ? scope.operation : undefined);
+}
 /** Checks response-body collection pointers, after bound-element substitution. */
 export function checkQuantifierOverNonCollection(contract) {
     const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
@@ -295,26 +431,10 @@ export function checkQuantifierOverNonCollection(contract) {
         const step = index.stepOf(stepId);
         if (step === undefined)
             return undefined;
-        return index.operationOf(step.operationId);
+        return anyOperationOf(index, step.operationId);
     };
     forEachContractExpression(contract, (site) => {
-        forEachQuantifierCollection(site.expression, null, '', (pointer, path) => {
-            const target = parseEvidenceTarget(pointer);
-            if (target.channel !== 'response-body')
-                return;
-            const operation = operationFor(site, target.stepId);
-            if (operation === undefined)
-                return;
-            const firstToken = target.tail.length === 1 ? target.tail[0] : undefined;
-            const declaredType = firstToken === undefined
-                ? undefined
-                : operation.responseDescriptor.types[firstToken];
-            if (declaredType !== undefined &&
-                declaredType !== null &&
-                NON_COLLECTION_TYPES.has(declaredType)) {
-                throw new StructuralFailure('quantifier-over-non-collection', `${site.artifactPath}${path}`, `"${pointer}" is declared "${declaredType}" by operation "${operation.operationId}", not a collection (AD-4)`);
-            }
-        });
+        checkQuantifiersAgainst(site.expression, site.artifactPath, (stepId) => operationFor(site, stepId));
     });
 }
 // Reference-set resolution.

package/dist/core/compile/forbidden-inputs.d.ts

@@ -1,5 +1,12 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
 /** `forbidden-input-floor-incomplete`: `forbiddenInputs` omits a floor member. */
 export declare function checkForbiddenInputFloor(contract: EvalContract): void;
-/** `scoped-reference-resolves-forbidden`: any scoped reference is forbidden. */
+/**
+ * `scoped-reference-resolves-forbidden`: any scoped reference is forbidden,
+ * wherever the contract writes it down. `scopedResources` is read first and
+ * `testData.resources` second, each with its own message and artifact path, so
+ * a contract carrying both reports the field AD-16 names by that word. The
+ * second address uses the caller-keyed form `interface-inventory.ts` already
+ * emits, since that list is keyed by name rather than indexed.
+ */
 export declare function checkScopedResourceReferences(contract: EvalContract): void;

package/dist/core/compile/forbidden-inputs.js

@@ -10,10 +10,23 @@ export function checkForbiddenInputFloor(contract) {
         }
     }
 }
-/** `scoped-reference-resolves-forbidden`: any scoped reference is forbidden. */
+/**
+ * `scoped-reference-resolves-forbidden`: any scoped reference is forbidden,
+ * wherever the contract writes it down. `scopedResources` is read first and
+ * `testData.resources` second, each with its own message and artifact path, so
+ * a contract carrying both reports the field AD-16 names by that word. The
+ * second address uses the caller-keyed form `interface-inventory.ts` already
+ * emits, since that list is keyed by name rather than indexed.
+ */
 export function checkScopedResourceReferences(contract) {
     const resource = contract.scopedResources?.[0];
-    if (resource === undefined)
+    if (resource !== undefined) {
+        throw new StructuralFailure('scoped-reference-resolves-forbidden', 'EvalContract.scopedResources[0].reference', `scoped resource reference "${resource.reference}" is forbidden (AD-16)`);
+    }
+    // Sorted, so which of several declared resources is reported never depends
+    // on the authored key order.
+    const declared = Object.keys(contract.testData.resources ?? {}).sort()[0];
+    if (declared === undefined)
         return;
-    throw new StructuralFailure('scoped-reference-resolves-forbidden', 'EvalContract.scopedResources[0].reference', `scoped resource reference "${resource.reference}" is forbidden (AD-16)`);
+    throw new StructuralFailure('scoped-reference-resolves-forbidden', `EvalContract.testData.resources[${JSON.stringify(declared)}]`, `declared test-data resource "${declared}" is a scoped resource reference and is forbidden (AD-16)`);
 }

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

@@ -1,10 +1,65 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
-/** Rejects permitted interface kinds that this contract version cannot run. */
+import type { AnyOperation } from '../schemas/interface.ts';
 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;
+/**
+ * The separator between a command's executable and each subcommand segment,
+ * declared once so the contract side and AD-40's corpus side cannot disagree
+ * about it. A space, matching the way the identity is written on a terminal.
+ */
+export declare const COMMAND_SIGNATURE_SEPARATOR = " ";
+/**
+ * The command counterpart of `operationSignature`, compared literally.
+ *
+ * There is no erasure step. A subcommand path carries no parameters: a
+ * command's variable inputs are its arguments and options, which live in the
+ * request shape. Erasing a subcommand segment would make `tool review` and
+ * `tool report` one signature, which is the opposite of what erasure is for.
+ */
+export declare function commandSignature(operation: {
+    readonly invocation: {
+        readonly executable: string;
+        readonly subcommandPath: readonly string[];
+    };
+}): string;
+/** The transport identity of an operation of either kind. */
+export declare const anyOperationSignature: (operation: AnyOperation) => 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.
+ * `unresolved-artifact-reference`: an artifact identifier nothing declares.
+ *
+ * Two sites name one: an evidence pointer's identifier segment, and a command
+ * operation's own `descriptorChannel` when it nominates an artifact. Both are
+ * authoring faults the compiler can see, and both take a code rather than
+ * resolving `absent`, on AD-26's own precedent for a dangling reference-set
+ * identifier: `absent` is defined over pointers that do not resolve against
+ * observed evidence, and a dangling declaration is neither.
+ */
+export declare function checkArtifactReferences(contract: EvalContract): void;
+/**
+ * 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

@@ -2,26 +2,70 @@
  * Checks interface kinds, inventory-wide operation signatures, and step input
  * bindings against each operation's request shape.
  */
+import { boundChannelsOf, declaredArtifactsOf, descriptorArtifactOf, isCommandOperation, requestShapeOf, } from '../declared-inputs.js';
 import { StructuralFailure } from '../failure-codes.js';
-import { TRANSPORT_CHANNELS } from '../schemas/pointer.js';
-import { buildPlanIndex } from '../seal/plan-index.js';
-/** Rejects permitted interface kinds that this contract version cannot run. */
+import { operationsOf } from '../schemas/interface.js';
+import { anyOperationOf, buildPlanIndex, parseEvidenceTarget, } from '../seal/plan-index.js';
+import { forEachArtifactPointer } from './reachability.js';
+/**
+ * Rejects permitted interface kinds whose probe semantics are undeclared.
+ *
+ * AD-10 closed all three non-api kinds and named the condition for opening
+ * one: the semantics have to be declared. They are declared for `cli`, so it
+ * runs; `web` and `mcp` are still undeclared and still fail here, which is
+ * what keeps this code fireable and keeps AD-10's sentence true of them.
+ */
+const SUPPORTED_INTERFACE_KINDS = ['api', 'cli'];
 export function checkInterfaceKind(contract) {
     for (const iface of contract.permittedInterfaces) {
-        if (iface.kind !== 'api') {
-            throw new StructuralFailure('unsupported-interface-kind', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].kind`, `"${iface.kind}" is not supported in v0; only "api" is (AD-10)`);
+        if (!SUPPORTED_INTERFACE_KINDS.includes(iface.kind)) {
+            throw new StructuralFailure('unsupported-interface-kind', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].kind`, `"${iface.kind}" is not supported; "api" and "cli" are (AD-10)`);
         }
     }
 }
 /** 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)}`;
+}
+/**
+ * The separator between a command's executable and each subcommand segment,
+ * declared once so the contract side and AD-40's corpus side cannot disagree
+ * about it. A space, matching the way the identity is written on a terminal.
+ */
+export const COMMAND_SIGNATURE_SEPARATOR = ' ';
+/**
+ * The command counterpart of `operationSignature`, compared literally.
+ *
+ * There is no erasure step. A subcommand path carries no parameters: a
+ * command's variable inputs are its arguments and options, which live in the
+ * request shape. Erasing a subcommand segment would make `tool review` and
+ * `tool report` one signature, which is the opposite of what erasure is for.
+ */
+export function commandSignature(operation) {
+    return [
+        operation.invocation.executable,
+        ...operation.invocation.subcommandPath,
+    ].join(COMMAND_SIGNATURE_SEPARATOR);
+}
+/** The transport identity of an operation of either kind. */
+export const anyOperationSignature = (operation) => isCommandOperation(operation)
+    ? commandSignature(operation)
+    : operationSignature(operation);
 /** 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)}`;
+        for (const operation of operationsOf(iface)) {
+            const signature = anyOperationSignature(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,23 +75,85 @@ export function checkDuplicateOperationSignature(contract) {
     }
 }
 /**
- * Checks each binding key against its operation's request shape.
+ * `unresolved-artifact-reference`: an artifact identifier nothing declares.
+ *
+ * Two sites name one: an evidence pointer's identifier segment, and a command
+ * operation's own `descriptorChannel` when it nominates an artifact. Both are
+ * authoring faults the compiler can see, and both take a code rather than
+ * resolving `absent`, on AD-26's own precedent for a dangling reference-set
+ * identifier: `absent` is defined over pointers that do not resolve against
+ * observed evidence, and a dangling declaration is neither.
+ */
+export function checkArtifactReferences(contract) {
+    for (const iface of contract.permittedInterfaces) {
+        for (const operation of operationsOf(iface)) {
+            const declared = declaredArtifactsOf(operation);
+            const nominated = descriptorArtifactOf(operation);
+            if (nominated !== null && !declared.includes(nominated)) {
+                throw new StructuralFailure('unresolved-artifact-reference', `EvalContract.permittedInterfaces[logicalId=${iface.logicalId}].operations[operationId=${operation.operationId}].descriptorChannel.artifactId`, `nominates "${nominated}", which this operation does not declare it writes (AD-19, AD-26)`);
+            }
+        }
+    }
+    const index = buildPlanIndex(contract.interactionPlan, contract.permittedInterfaces, { duplicateIds: 'unresolved' });
+    forEachArtifactPointer(contract, (pointer, path) => {
+        const target = parseEvidenceTarget(pointer);
+        if (target.artifactId === null)
+            return;
+        const step = index.stepOf(target.stepId);
+        if (step === undefined)
+            return;
+        const operation = anyOperationOf(index, step.operationId);
+        // An unresolvable step or operation is `unreachable-check-evidence`'s,
+        // at a higher rung; this check has nothing to compare against.
+        if (operation === undefined)
+            return;
+        if (declaredArtifactsOf(operation).includes(target.artifactId))
+            return;
+        throw new StructuralFailure('unresolved-artifact-reference', path, `"${pointer}" names the "${target.artifactId}" artifact, which operation "${operation.operationId}" does not declare it writes (AD-26)`);
+    });
+}
+/**
+ * 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);
+        const operation = anyOperationOf(index, step.operationId);
         if (operation === undefined)
             continue;
-        for (const channel of TRANSPORT_CHANNELS) {
-            const binding = step.inputBinding[channel];
+        for (const { channel, bound: binding } of boundChannelsOf(step.inputBinding)) {
             if (binding === null)
                 continue;
-            const { requiredKeys, permittedKeys } = operation.requestShape[channel];
+            const shape = requestShapeOf(operation, channel);
+            // A step binding a channel of the other kind has no declared shape
+            // to answer to. Reporting it as an undeclared input is true as far
+            // as it goes: the operation declares no such channel, and so
+            // declares no such key on it.
+            const requiredKeys = shape?.requiredKeys ?? [];
+            const permittedKeys = shape?.permittedKeys ?? [];
             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,29 @@
 import type { EvalContract } from '../schemas/eval-contract.ts';
+import type { Expression } from '../schemas/expression.ts';
+import type { AnyOperation } from '../schemas/interface.ts';
 import { type PlanIndex } from '../seal/plan-index.ts';
+/**
+ * Every interaction-rooted pointer the contract writes down, wherever it sits:
+ * an oracle's check and its direction's evidence targets, a rubric criterion's
+ * evidence, and each operation's sensitivity-witness relation.
+ *
+ * Broader than `forEachCheckPointer`, which walks oracle checks alone, because
+ * an artifact identifier is an authoring fault at every site that names one and
+ * a check that walked only the checks would report half of them.
+ */
+export declare function forEachArtifactPointer(contract: EvalContract, visit: (pointer: string, artifactPath: string) => void): void;
 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: AnyOperation): void;
 type ReachabilityResult = {
     readonly reachable: true;
 } | {
@@ -9,7 +32,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. */