eval-quality 0.2.0 → 0.5.0

package/dist/core/score/quotation.js

@@ -43,12 +43,37 @@ import { serialize } from '../canonical/canonicalize.js';
  * Should canonicalization fault on a caller's record, the fault propagates,
  * which is what keeps this procedure from being circular with it.
  */
-export function projectChannel(observation, channel, artifactPath) {
+/**
+ * One tagged observed value as the text a quotation is compared against. A
+ * text body is its own value; a JSON body is its canonical serialisation, the
+ * same one `response-body` gets; an absent channel has no text.
+ */
+function observedText(body, artifactPath) {
+    if (body.kind === 'absent')
+        return null;
+    if (body.kind === 'text')
+        return body.value;
+    return serialize(body.value, artifactPath);
+}
+export function projectChannel(observation, channel, artifactPath, artifactId = null) {
     switch (channel) {
         case 'stdout':
-            return observation.stdout;
+            return observedText(observation.stdout, artifactPath);
         case 'stderr':
-            return observation.stderr;
+            return observedText(observation.stderr, artifactPath);
+        case 'artifact': {
+            // One named file's own text. Serializing the whole map instead was
+            // wrong twice over: it escaped every newline and quotation mark, so
+            // a quotation from a file with more than one line could never match,
+            // and it searched every file at once, so a quotation from a file the
+            // finding did not cite matched anyway.
+            if (artifactId === null)
+                return null;
+            if (!Object.hasOwn(observation.artifacts, artifactId))
+                return null;
+            const written = observation.artifacts[artifactId];
+            return written === undefined ? null : observedText(written, artifactPath);
+        }
         case 'response-status':
             return observation.responseStatus === null
                 ? null
@@ -73,7 +98,7 @@ export function projectChannel(observation, channel, artifactPath) {
  * Whether one quotation appears in one observation's named channel, verbatim.
  */
 function quotationWitnessed(quoted, observation, artifactPath) {
-    const projected = projectChannel(observation, quoted.channel, artifactPath);
+    const projected = projectChannel(observation, quoted.channel, artifactPath, quoted.artifactId);
     // A null projection witnesses nothing, and `false` is the answer: an
     // optional chain here would hand a caller `undefined` where the return type
     // says boolean.

package/dist/core/score/score.js

@@ -30,7 +30,7 @@
  */
 import { walkExpression } from '../compile/expression-legality.js';
 import { evaluateCoverage } from '../coverage/coverage.js';
-import { makePointerDenotesCollection, makeResolveOperand, } from '../evaluate/evidence-resolution.js';
+import { makePointerDenotesCollection, makeResolveOperand, referenceSetKeysOf, } from '../evaluate/evidence-resolution.js';
 import { resolveCheck } from '../evaluate/resolution.js';
 import { SEVERITY_LEVELS, } from '../schemas/eval-contract.js';
 import { buildPlanIndex } from '../seal/plan-index.js';
@@ -195,6 +195,29 @@ function trialSetDisagreementsOf(trials) {
     });
     return disagreements;
 }
+/**
+ * Cross-trial identifier reuse is NOT a collision, and this is where that was
+ * settled after being carried as an open question.
+ *
+ * `ingest` computes `duplicate-record-identifier` per sealed run record, since
+ * it sees one trial at a time, and nothing checks whether two DIFFERENT trials
+ * of one set reuse an observation, finding, or oracle-disposition identifier.
+ * That asymmetry looks like a gap beside `trial-set-field-disagreement`, which
+ * does compare `mode` and `evaluatorRecommendation` across trials.
+ *
+ * It is not one. A trial set is n independent evaluator runs of one contract,
+ * each producing its own record, and a harness that names its first observation
+ * `obs-1` names it that in every run. Reporting the second run for it would
+ * make a repeated run Invalid by construction, which is the opposite of what a
+ * trial set is for. The fields that ARE compared across trials are compared
+ * because they describe the SET rather than a run within it: two trials
+ * disagreeing about which mode they ran under cannot both be true of one set,
+ * while two trials both carrying `obs-1` are two true statements about two
+ * runs.
+ *
+ * The pooled basis this stage builds carries each entry with the trial it came
+ * from, so a repeated identifier is never resolved against the wrong row.
+ */
 /** Every `IngestCondition` of one `kind` across every trial, in trial order. */
 function conditionsAcrossTrials(trials, kind) {
     return trials.flatMap((trial) => trial.conditions.filter((condition) => condition.kind === kind));
@@ -246,6 +269,9 @@ export const score = (contract, trials, probe, preflightVerdict, policy, waiver,
         id,
         declaration.members,
     ]));
+    // The declared keys the members map above drops. `set-membership`'s set
+    // position reads the single declared key off each member.
+    const referenceSetKeys = referenceSetKeysOf(contract);
     const judgeConduct = judgeConductOf(contract, trials);
     const allOutcomes = [];
     // The full `EvidenceArtifact.outcomes` shape, built alongside `allOutcomes`
@@ -317,7 +343,7 @@ export const score = (contract, trials, probe, preflightVerdict, policy, waiver,
                 entry.step.cardinality !== 'any');
             const checkResolution = check === null
                 ? null
-                : resolveCheck(check, resolveOperand, pointerDenotesCollection, policy.regexMatchStepBudget, `EvalContract.oracles[id=${oracle.id}].check`);
+                : resolveCheck(check, resolveOperand, pointerDenotesCollection, referenceSetKeys, policy.regexMatchStepBudget, `EvalContract.oracles[id=${oracle.id}].check`);
             // Every disposition this trial records for this oracle, not just
             // the first: `SealedRunRecord.oracleDispositions` carries no
             // uniqueness constraint on `oracleId`, and ingest's

package/dist/core/score/strength.d.ts

@@ -45,5 +45,14 @@ export declare function buildStrengthVector(admitted: readonly QualifiedProbe[],
  * on it is not fit to decide a comparison either way. The severity-floor
  * override runs only against the side the raw comparison favoured, and only
  * ever downgrades that result to `incomparable`.
+ *
+ * That scope is AD-7's own and not an omission: its words are that a contract
+ * missing a behaviour at or above the floor "never dominates" one that caught
+ * it, which constrains dominance and says nothing about equivalence. Two
+ * vectors that are component-wise equal are `equivalent` whatever their
+ * severities, because neither is dominating anything for the override to
+ * withdraw. Widening it to `equivalent` would be a new rule rather than this
+ * one applied more thoroughly, and it is written down here so the asymmetry
+ * reads as a decision rather than a gap.
  */
 export declare function compareDominance(a: ComparableResult, b: ComparableResult, severityFloor: Severity): DominanceRelationValue;

package/dist/core/score/strength.js

@@ -44,7 +44,18 @@ const classStrengthOf = (probesInClass, results) => {
         return null;
     let exercised = 0;
     let caught = 0;
+    // Counted once per identifier, not once per entry. AD-7's rate is over
+    // unique qualified probe identifiers, and nothing in `src/` enforces that
+    // `admitted` carries each identifier once: no probe-corpus schema exists,
+    // so the uniqueness is inherited from upstream qualification rather than
+    // checked. A repeated identifier would otherwise count its trial-set
+    // result twice on both sides of the same ratio, which leaves the rate
+    // right and the raw counts wrong.
+    const counted = new Set();
     for (const { probe } of probesInClass) {
+        if (counted.has(probe.probeId))
+            continue;
+        counted.add(probe.probeId);
         const result = results.get(probe.probeId);
         if (result === undefined || !result.exercised)
             continue;
@@ -123,7 +134,21 @@ function componentComparison(a, b) {
         return 'b-dominates-a';
     return 'incomparable';
 }
-const atOrAboveFloor = (severity, floor) => SEVERITY_LEVELS.indexOf(severity) >= SEVERITY_LEVELS.indexOf(floor);
+/**
+ * Both operands are looked up before they are compared, because `indexOf`
+ * answers `-1` for a value the ladder does not name and `-1 >= -1` reads as
+ * "at or above the floor" for two values that are on no ladder at all. A
+ * severity outside the closed set is not at or above anything, and a floor
+ * outside it bounds nothing, so either one absent is `false` rather than a
+ * comparison of two absences.
+ */
+const atOrAboveFloor = (severity, floor) => {
+    const rank = SEVERITY_LEVELS.indexOf(severity);
+    const bound = SEVERITY_LEVELS.indexOf(floor);
+    if (rank < 0 || bound < 0)
+        return false;
+    return rank >= bound;
+};
 /**
  * Keyed by the first outcome carrying each `probeId`, not the last: two
  * `Outcome` entries sharing one `probeId` is itself a defect somewhere
@@ -174,6 +199,15 @@ function favoredMissesWhatOtherCaught(favored, other, severityFloor) {
  * on it is not fit to decide a comparison either way. The severity-floor
  * override runs only against the side the raw comparison favoured, and only
  * ever downgrades that result to `incomparable`.
+ *
+ * That scope is AD-7's own and not an omission: its words are that a contract
+ * missing a behaviour at or above the floor "never dominates" one that caught
+ * it, which constrains dominance and says nothing about equivalence. Two
+ * vectors that are component-wise equal are `equivalent` whatever their
+ * severities, because neither is dominating anything for the override to
+ * withdraw. Widening it to `equivalent` would be a new rule rather than this
+ * one applied more thoroughly, and it is written down here so the asymmetry
+ * reads as a decision rather than a gap.
  */
 export function compareDominance(a, b, severityFloor) {
     if (a.comparabilityKey !== b.comparabilityKey)

package/dist/core/score/witness.d.ts

@@ -1,3 +1,24 @@
+/**
+ * AD-40's witness match: whether a finding cited against a probe actually
+ * witnessed the defect that probe seeded.
+ *
+ * This is the input that makes non-detection reachable. Without it, an oracle
+ * that correctly confirmed an untouched behaviour and one that failed to detect
+ * the seeded defect present identical inputs, so any table obeying AD-3 must
+ * give both the same answer and the catch rate is 1.00 by construction.
+ *
+ * Pure and total on its ordinary path, and no AD-6 outcome state is assigned
+ * here. The result is a fact about evidence; turning it into an outcome state
+ * is the decision procedure's.
+ *
+ * One deliberate non-totality: a `RuntimeFault` from the shipped evaluator
+ * propagates undecorated. A fault never becomes a verdict, and AD-28 makes it
+ * an invalidating condition under AD-21 rather than a behavioural result, so
+ * catching one here would convert AD-21's fault exit into a scored run. The
+ * qualification gate rejects every operand class that makes the evaluator's
+ * four plain-`Error` sites reachable, which leaves exactly two data-dependent
+ * `RuntimeFault`s: an exhausted regex budget and a non-canonicalizable value.
+ */
 import type { DefectSignature } from '../schemas/defect-signature.ts';
 import type { PermittedInterface } from '../schemas/interface.ts';
 import type { Probe } from '../schemas/probe.ts';

package/dist/core/score/witness.js

@@ -19,11 +19,12 @@
  * four plain-`Error` sites reachable, which leaves exactly two data-dependent
  * `RuntimeFault`s: an exhausted regex budget and a non-canonicalizable value.
  */
+import { requestShapeOf } from '../declared-inputs.js';
 import { makeResolveOperand } from '../evaluate/evidence-resolution.js';
 import { resolveCheck } from '../evaluate/resolution.js';
 import { makeWitnessPointerDenotesCollection } from '../preflight/witness-evidence.js';
 import { OBSERVED_STEP_ID } from '../schemas/defect-signature.js';
-import { TRANSPORT_CHANNELS } from '../schemas/pointer.js';
+import { INPUT_CHANNELS } from '../schemas/pointer.js';
 import { deepEquals, jsonTypeOf } from './bindings.js';
 import { resolveHomeOperation } from './qualification.js';
 /**
@@ -73,7 +74,7 @@ export const PROBE_WITNESS_RESULTS = [
  * probe has no interaction plan to index.
  */
 function selectorAdmits(binding, observation, operation) {
-    for (const channel of TRANSPORT_CHANNELS) {
+    for (const channel of INPUT_CHANNELS) {
         const channelBinding = binding[channel];
         if (channelBinding === null)
             continue;
@@ -94,7 +95,7 @@ function selectorAdmits(binding, observation, operation) {
             }
             if (value.matcher === 'any')
                 continue;
-            const declared = operation.requestShape[channel].types[key];
+            const declared = requestShapeOf(operation, channel)?.types[key];
             if (declared === undefined || declared === null)
                 return false;
             if (jsonTypeOf(actual) === declared)
@@ -119,7 +120,11 @@ const bySequence = (a, b) => a.sequence - b.sequence || (a.observationId < b.obs
  * than an accident.
  */
 function resolveCondition(signature, observation, operation, artifactPath) {
-    return resolveCheck(signature.condition.predicate, makeResolveOperand({ [OBSERVED_STEP_ID]: observation }, {}), makeWitnessPointerDenotesCollection(operation), PROBE_REGEX_MATCH_STEP_BUDGET, artifactPath).resolution;
+    return resolveCheck(signature.condition.predicate, makeResolveOperand({ [OBSERVED_STEP_ID]: observation }, {}), makeWitnessPointerDenotesCollection(operation), 
+    // No reference sets, matching the empty members map above: the
+    // qualification gate rejects a reference-set operand in a defect
+    // signature under `condition-reference-set-operand`.
+    {}, PROBE_REGEX_MATCH_STEP_BUDGET, artifactPath).resolution;
 }
 const defectFindingsFor = (findings, probeId) => findings.filter((finding) => finding.findingType === 'defect' && finding.probeId === probeId);
 /**

package/dist/core/seal/derived-reference.d.ts

@@ -1,11 +1,4 @@
-/**
- * The derived-reference vocabulary (AD-16). Renders an evidence-target
- * pointer, or a temporally-paired pair, as a description of the step's
- * operation and selection predicate; the step's own identifier never appears.
- * Resolves pointers through a `PlanIndex` into a phrase, kept apart from
- * `plan-index.ts`'s resolving and `direction-prose.ts`'s relation templates.
- */
-import type { Operation } from '../schemas/interface.ts';
+import type { AnyOperation } from '../schemas/interface.ts';
 import type { InteractionStep } from '../schemas/plan.ts';
 import { type PlanIndex } from './plan-index.ts';
 /**
@@ -21,7 +14,7 @@ import { type PlanIndex } from './plan-index.ts';
  * duplicate `stepId` check if two siblings still collide after full
  * escalation.
  */
-export declare function renderStepReference(step: InteractionStep, operation: Operation, siblings: readonly InteractionStep[], index: PlanIndex): string;
+export declare function renderStepReference(step: InteractionStep, operation: AnyOperation, siblings: readonly InteractionStep[], index: PlanIndex): string;
 /**
  * Renders every evidence target a direction declares as one canonically
  * ordered, order-independent clause: byte-identical under any permutation of

package/dist/core/seal/derived-reference.js

@@ -1,8 +1,20 @@
-import { parseEvidenceTarget, resolveOperation, resolveStep, } from './plan-index.js';
+/**
+ * The derived-reference vocabulary (AD-16). Renders an evidence-target
+ * pointer, or a temporally-paired pair, as a description of the step's
+ * operation and selection predicate; the step's own identifier never appears.
+ * Resolves pointers through a `PlanIndex` into a phrase, kept apart from
+ * `plan-index.ts`'s resolving and `direction-prose.ts`'s relation templates.
+ */
+import { boundChannelsOf, isCommandOperation } from '../declared-inputs.js';
+import { StructuralFailure } from '../failure-codes.js';
+import { anyOperationOf, parseEvidenceTarget, resolveStep, } from './plan-index.js';
 function resolveEvidenceTarget(pointer, index) {
     const target = parseEvidenceTarget(pointer);
     const step = resolveStep(index, target.stepId);
-    const operation = resolveOperation(index, step.operationId);
+    const operation = anyOperationOf(index, step.operationId);
+    if (operation === undefined) {
+        throw new TypeError(`step names an operation the permitted interfaces do not declare: ${step.operationId}`);
+    }
     return { target, step, operation };
 }
 // ---- joining ---------------------------------------------------------
@@ -21,30 +33,31 @@ function joinWithAnd(items) {
 // ---- operation identity -----------------------------------------------
 // Humanizing a kebab-case operationId is injective on distinct ids, and
 // `buildPlanIndex` already rejects a duplicate `operationId` across
-// interfaces, so two resolved operations never share this phrase. `method`
-// and `pathTemplate` are never printed here: AD-16 withholds the operation
-// inventory from the brief.
+// interfaces, so two resolved operations never share this phrase. The
+// transport identity is never printed here, whichever kind it is: AD-16
+// withholds the operation inventory from the brief, so neither a method and a
+// path template nor an executable and a subcommand path reach an evaluator.
+//
+// The noun follows the kind. Calling a command an endpoint told the evaluator
+// something false about what it was reading, and the word is the only thing
+// this phrase says beyond the operation's own name.
 function operationReference(operation) {
-    return `the ${operation.operationId.split('-').join(' ')} endpoint`;
+    const name = operation.operationId.split('-').join(' ');
+    return isCommandOperation(operation)
+        ? `the ${name} command`
+        : `the ${name} endpoint`;
 }
 const ESCALATION_LEVELS = [
     'generic',
     'kind',
     'literal',
 ];
-const TRANSPORT_ORDER = [
-    'path',
-    'query',
-    'header',
-    'body',
-];
-// Sorted by transport channel in fixed order, then by key name, so this
+// Sorted by input channel in `INPUT_CHANNELS` order, then by key name, so this
 // never depends on a binding map's insertion order and the rendered prose
-// stays permutation-invariant.
+// stays permutation-invariant. `boundChannelsOf` supplies the channel order.
 function bindingEntries(step) {
     const entries = [];
-    for (const transportChannel of TRANSPORT_ORDER) {
-        const map = step.inputBinding[transportChannel];
+    for (const { channel: transportChannel, bound: map } of boundChannelsOf(step.inputBinding)) {
         if (map === null)
             continue;
         for (const key of Object.keys(map).sort()) {
@@ -99,9 +112,10 @@ function formatLiteral(literal) {
 // predecessor separates them by its own binding clause. Two predecessors that
 // are themselves irreducible still tie, and the throw there is correct: the
 // declared structure does not distinguish them, which is the same answer
-// `irreducibleCollisionPair` already gets. That throw is a bare `TypeError`
-// rather than a coded failure, which is a pre-existing gap this widens; the
-// deferred-work entry names hoisting the collision check to compile time.
+// `irreducibleCollisionPair` already gets. That throw is a coded
+// `StructuralFailure` under `irreducible-step-reference`, and it is
+// hoisted to compile time by `checkStepReferenceReducibility`, which runs this
+// same ladder and reports the same code before `seal` is ever called.
 //
 // It does NOT call `renderStepReference`, so none of that function's
 // constraints apply: no direction-scoped sibling list is consulted, so AD-16's
@@ -191,7 +205,7 @@ function renderCaptureGroup(group, level, index, rendering, budget) {
     const names = joinWithAnd(group.entries.map(entryName));
     const locals = joinWithAnd(group.targets.map(localTargetPhrase));
     const step = index.stepOf(group.stepId);
-    const operation = step === undefined ? undefined : index.operationOf(step.operationId);
+    const operation = step === undefined ? undefined : anyOperationOf(index, step.operationId);
     if (step === undefined || operation === undefined) {
         return unexpandedGroup(group);
     }
@@ -222,7 +236,7 @@ function expandableCapture(entry, level, index, rendering, budget) {
     const step = index.stepOf(target.stepId);
     if (step === undefined)
         return null;
-    return index.operationOf(step.operationId) === undefined ? null : target;
+    return anyOperationOf(index, step.operationId) === undefined ? null : target;
 }
 // Renders one entry on its own. Every captured entry that expands lands in a
 // group instead, so the arm here is the level-independent fallback.
@@ -355,7 +369,13 @@ export function renderStepReference(step, operation, siblings, index) {
         if (!starved)
             break;
     }
-    throw new TypeError(`two or more steps invoking operation "${operation.operationId}" that this direction references render to the same derived reference even fully escalated; the declared structure does not distinguish them`);
+    // Coded rather than a bare `TypeError`. A contract reaching here passed
+    // every compile check and then failed at seal time with a stack trace, and
+    // the defect is an ordinary authoring fault: two steps the declared
+    // structure does not tell apart. `checkStepReferenceReducibility` runs this
+    // same ladder at compile time so the fault is reported before seal, and
+    // this throw is what it catches.
+    throw new StructuralFailure('irreducible-step-reference', `EvalContract.interactionPlan[operationId=${operation.operationId}]`, `two or more steps invoking operation "${operation.operationId}" that one direction references render to the same derived reference even fully escalated; the declared structure does not distinguish them (AD-16, AD-3)`);
 }
 function siblingsByOperation(resolved) {
     const map = new Map();
@@ -422,6 +442,20 @@ function localTargetPhrase(target) {
             return field !== null
                 ? `the ${field} field of its standard error`
                 : 'the standard error you obtained';
+        case 'artifact': {
+            if (target.artifactId === null) {
+                // Unreachable: `parseEvidenceTarget` sets this exactly when the
+                // channel is 'artifact'.
+                throw new TypeError('artifact evidence target names no artifact');
+            }
+            // The artifact is named for the same reason the transport channel
+            // is: two files can carry the same field name, and an evaluator
+            // reading "its findings field" twice cannot tell which file it
+            // means.
+            return field !== null
+                ? `the ${field} field of the ${target.artifactId} it wrote`
+                : `the ${target.artifactId} it wrote`;
+        }
     }
 }
 function fullTargetPhrase(resolved, siblingsOf, index) {
@@ -436,7 +470,12 @@ function fullTargetPhrase(resolved, siblingsOf, index) {
 // 'b']`). Both would join to the same `".../a/b"` string, producing a false
 // tie in `sentFirstOrder` below.
 function channelSignature(target) {
-    return JSON.stringify([target.channel, target.transportChannel, target.tail]);
+    return JSON.stringify([
+        target.channel,
+        target.transportChannel,
+        target.artifactId,
+        target.tail,
+    ]);
 }
 // A total order over one pair, independent of argument order. The final
 // reference-comparison rung fires only on a genuine tie, such as the same

package/dist/core/seal/plan-index.d.ts

@@ -1,7 +1,7 @@
 /** resolves a pointer to its step and operation; nothing about reachability. */
-import type { Operation, PermittedInterface } from '../schemas/interface.ts';
+import type { AnyOperation, CommandOperation, InterfaceKindName, Operation, PermittedInterface } from '../schemas/interface.ts';
 import type { InteractionStep } from '../schemas/plan.ts';
-import { type EvidenceChannelName, type TransportChannelName } from '../schemas/pointer.ts';
+import { type EvidenceChannelName, type InputChannelName } from '../schemas/pointer.ts';
 /**
  * Exported so `core/evaluate/evidence-resolution.ts` decodes pointer tails
  * with these same two functions, avoiding a second private copy (the drift
@@ -17,7 +17,8 @@ export declare const decodeTail: (tailSource: string) => readonly string[];
 export type EvidenceTarget = {
     stepId: string;
     channel: EvidenceChannelName;
-    transportChannel: TransportChannelName | null;
+    transportChannel: InputChannelName | null;
+    artifactId: string | null;
     tail: readonly string[];
 };
 /**
@@ -34,10 +35,18 @@ export declare function parseEvidenceTarget(pointer: string): EvidenceTarget;
  * about reachability or channel typing; the general addressing-grammar
  * resolver lives in `core/evaluate/evidence-resolution.ts` and reachability
  * in `core/compile/reachability.ts`.
+ *
+ * `operationOf` stays narrow on purpose. It hands a resolved `Operation` to
+ * every downstream consumer, so widening its return type to the operation
+ * union would retype seventeen files at once. A command operation resolves to
+ * `undefined` from it and to a value from `commandOperationOf`, and each
+ * caller that has to branch reads the declaring kind first.
  */
 export type PlanIndex = {
     stepOf: (stepId: string) => InteractionStep | undefined;
     operationOf: (operationId: string) => Operation | undefined;
+    commandOperationOf: (operationId: string) => CommandOperation | undefined;
+    interfaceKindOf: (operationId: string) => InterfaceKindName | undefined;
     stepsUsing: (operationId: string) => readonly InteractionStep[];
 };
 export type PlanIndexOptions = {
@@ -59,5 +68,11 @@ export declare function buildPlanIndex(interactionPlan: readonly InteractionStep
  * `RuntimeFault`.
  */
 export declare function resolveStep(index: PlanIndex, stepId: string): InteractionStep;
+/**
+ * The declared operation of whichever kind, for the callers that read only
+ * fields both shapes carry. Callers reading a kind-specific field ask
+ * `interfaceKindOf` first and then take the matching accessor.
+ */
+export declare const anyOperationOf: (index: PlanIndex, operationId: string) => AnyOperation | undefined;
 /** Resolves an operation id through the index or throws. See `resolveStep`. */
 export declare function resolveOperation(index: PlanIndex, operationId: string): Operation;

package/dist/core/seal/plan-index.js

@@ -1,4 +1,5 @@
-import { SCALAR_CHANNELS, TAIL_BEARING_CHANNELS, TRANSPORT_CHANNELS, TRANSPORT_ROOTED_CHANNEL, } from '../schemas/pointer.js';
+import { operationsOf } from '../schemas/interface.js';
+import { IDENTIFIER_ROOTED_CHANNEL, INPUT_CHANNELS, SCALAR_CHANNELS, TAIL_BEARING_CHANNELS, TRANSPORT_ROOTED_CHANNEL, } from '../schemas/pointer.js';
 import { IDENTIFIER_CHARSET_SOURCE } from '../schemas/primitives.js';
 // An RFC 6901 reference token, respelled here because pointer.ts keeps its
 // own TOKEN/TAIL fragments private. IDENTIFIER_CHARSET_SOURCE and the channel
@@ -14,10 +15,10 @@ const alternation = (members) => members.join('|');
 // Named capture groups replace positional indices, avoiding a fragile
 // dependency on `IDENTIFIER_CHARSET_SOURCE` staying free of its own capturing
 // groups.
-const EVIDENCE_TARGET_PATTERN = new RegExp(`^/interactions/(?<stepId>${IDENTIFIER_CHARSET_SOURCE})/(?:(?<tailBearingChannel>${alternation(TAIL_BEARING_CHANNELS)})(?<tailBearingTail>${TAIL_SOURCE})|(?<scalarChannel>${alternation(SCALAR_CHANNELS)})|${TRANSPORT_ROOTED_CHANNEL}/(?<transportChannel>${alternation(TRANSPORT_CHANNELS)})(?<callInputsTail>${TAIL_SOURCE}))$`);
+const EVIDENCE_TARGET_PATTERN = new RegExp(`^/interactions/(?<stepId>${IDENTIFIER_CHARSET_SOURCE})/(?:(?<tailBearingChannel>${alternation(TAIL_BEARING_CHANNELS)})(?<tailBearingTail>${TAIL_SOURCE})|(?<scalarChannel>${alternation(SCALAR_CHANNELS)})|${TRANSPORT_ROOTED_CHANNEL}/(?<transportChannel>${alternation(INPUT_CHANNELS)})(?<callInputsTail>${TAIL_SOURCE})|${IDENTIFIER_ROOTED_CHANNEL}/(?<artifactId>${IDENTIFIER_CHARSET_SOURCE})(?<artifactTail>${TAIL_SOURCE}))$`);
 const isEvidenceChannel = (value) => TAIL_BEARING_CHANNELS.includes(value) ||
     SCALAR_CHANNELS.includes(value);
-const isTransportChannel = (value) => TRANSPORT_CHANNELS.includes(value);
+const isInputChannel = (value) => INPUT_CHANNELS.includes(value);
 /**
  * Exported so `core/evaluate/evidence-resolution.ts` decodes pointer tails
  * with these same two functions, avoiding a second private copy (the drift
@@ -47,6 +48,7 @@ export function parseEvidenceTarget(pointer) {
             stepId,
             channel: groups.scalarChannel,
             transportChannel: null,
+            artifactId: null,
             tail: [],
         };
     }
@@ -59,21 +61,32 @@ export function parseEvidenceTarget(pointer) {
             stepId,
             channel: groups.tailBearingChannel,
             transportChannel: null,
+            artifactId: null,
             tail: decodeTail(groups.tailBearingTail ?? ''),
         };
     }
     if (groups.transportChannel !== undefined) {
-        if (!isTransportChannel(groups.transportChannel)) {
-            // Unreachable: TRANSPORT_CHANNELS is exactly what this group can match.
+        if (!isInputChannel(groups.transportChannel)) {
+            // Unreachable: INPUT_CHANNELS is exactly what this group can match.
             throw new TypeError(`call-inputs evidence target names no transport channel: ${pointer}`);
         }
         return {
             stepId,
             channel: 'call-inputs',
             transportChannel: groups.transportChannel,
+            artifactId: null,
             tail: decodeTail(groups.callInputsTail ?? ''),
         };
     }
+    if (groups.artifactId !== undefined) {
+        return {
+            stepId,
+            channel: IDENTIFIER_ROOTED_CHANNEL,
+            transportChannel: null,
+            artifactId: groups.artifactId,
+            tail: decodeTail(groups.artifactTail ?? ''),
+        };
+    }
     // Unreachable: the pattern's three branches are exhaustive once stepId matched.
     throw new TypeError(`not an interaction-rooted evidence pointer of a recognized channel: ${pointer}`);
 }
@@ -109,25 +122,42 @@ export function buildPlanIndex(interactionPlan, permittedInterfaces, options = {
         }
     }
     const operations = new Map();
+    const commandOperations = new Map();
+    const kinds = new Map();
     const duplicateOperationIds = new Set();
     for (const iface of permittedInterfaces) {
-        for (const operation of iface.operations) {
-            if (operations.has(operation.operationId) ||
+        for (const operation of operationsOf(iface)) {
+            if (kinds.has(operation.operationId) ||
                 duplicateOperationIds.has(operation.operationId)) {
                 if (duplicateIds === 'throw') {
                     throw new TypeError(`duplicate operation id across permitted interfaces: ${operation.operationId}`);
                 }
                 operations.delete(operation.operationId);
+                commandOperations.delete(operation.operationId);
+                kinds.delete(operation.operationId);
                 duplicateOperationIds.add(operation.operationId);
             }
             else {
-                operations.set(operation.operationId, operation);
+                kinds.set(operation.operationId, iface.kind);
+                // Sorted into the two maps by the interface's own kind rather
+                // than by probing the operation for a field: `web` and `mcp`
+                // carry the api operation shape and belong in the same map as
+                // `api`, since every consumer of a resolved operation reads
+                // the same declared fields off all three.
+                if (iface.kind === 'cli') {
+                    commandOperations.set(operation.operationId, operation);
+                }
+                else {
+                    operations.set(operation.operationId, operation);
+                }
             }
         }
     }
     return {
         stepOf: (stepId) => steps.get(stepId),
         operationOf: (operationId) => operations.get(operationId),
+        commandOperationOf: (operationId) => commandOperations.get(operationId),
+        interfaceKindOf: (operationId) => kinds.get(operationId),
         stepsUsing: (operationId) => stepsByOperation.get(operationId) ?? [],
     };
 }
@@ -145,6 +175,12 @@ export function resolveStep(index, stepId) {
     }
     return step;
 }
+/**
+ * The declared operation of whichever kind, for the callers that read only
+ * fields both shapes carry. Callers reading a kind-specific field ask
+ * `interfaceKindOf` first and then take the matching accessor.
+ */
+export const anyOperationOf = (index, operationId) => index.operationOf(operationId) ?? index.commandOperationOf(operationId);
 /** Resolves an operation id through the index or throws. See `resolveStep`. */
 export function resolveOperation(index, operationId) {
     const operation = index.operationOf(operationId);

package/dist/index.d.ts

@@ -12,4 +12,4 @@ export type { ScoringPolicy } from './core/schemas/scoring-policy.ts';
 export type { SealedEvaluatorBrief } from './core/schemas/sealed-evaluator-brief.ts';
 export type { SealedRunRecord } from './core/schemas/sealed-run-record.ts';
 export type { FixtureReset, ManifestationWitness, SensitivityWitness, SensitivityWitnessLeg, WitnessChannel, WitnessInputs, } from './core/schemas/sensitivity-witness.ts';
-export declare const VERSION = "0.2.0";
+export declare const VERSION = "0.5.0";

package/dist/index.js

@@ -19,4 +19,4 @@
 // subpath, where AD-37 puts the conformance definition an adapter author
 // reads; the reference adapters stay at `eval-quality/adapters`.
 export * from './application/index.js';
-export const VERSION = '0.2.0';
+export const VERSION = '0.5.0';