eval-quality 1.4.2 → 3.0.0

package/dist/core/compile/schema-version.js

@@ -17,9 +17,17 @@
  * happened to notice first.
  */
 import { RuntimeFault } from '../schemas/faults.js';
-/** `schema-version-mismatch`: the stamp is not the version this build reads. */
-export function checkSchemaVersion(stamped, accepted, artifactPath) {
+/**
+ * `schema-version-mismatch`: the stamp is not the version this build reads.
+ *
+ * An options object rather than four positional arguments. `artifactPath` and
+ * `consequence` are both free-form strings, and transposed they typecheck: the
+ * fault's `artifactPath`, which callers read programmatically, would then hold
+ * a sentence.
+ */
+export function checkSchemaVersion(options) {
+    const { stamped, accepted, artifactPath, consequence } = options;
     if (stamped === accepted)
         return;
-    throw new RuntimeFault('schema-version-mismatch', artifactPath, `carries "schemaVersion" ${stamped} where this build reads ${accepted}; a contract written for another version is not read leniently, since its stale version would travel into the scoring version (AD-11)`);
+    throw new RuntimeFault('schema-version-mismatch', artifactPath, `carries "schemaVersion" ${stamped} where this build reads ${accepted}; an artifact written for another version is not read leniently, ${consequence} (AD-11)`);
 }

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

@@ -15,8 +15,10 @@ import { declaresNoRequestKeys } from '../declared-inputs.ts';
 import type { EvalContract } from '../schemas/eval-contract.ts';
 import type { AnyOperation } from '../schemas/interface.ts';
 import type { InputChannelName } from '../schemas/pointer.ts';
-import { type ApiWitnessInputs, type WitnessChannel, type WitnessInputs } from '../schemas/sensitivity-witness.ts';
+import { type ApiWitnessInputs, type McpWitnessInputs, type WitnessChannel, type WitnessInputs } from '../schemas/sensitivity-witness.ts';
 export { declaresNoRequestKeys };
+/** Which spelling this leg uses. `arguments` is the tool-call shape's one key. */
+export declare const isMcpWitnessInputs: (inputs: WitnessInputs) => inputs is McpWitnessInputs;
 /**
  * The transport spelling, for the consumers that can only send one: the probe
  * port carries a method, a path template, and the four transport channels.
@@ -41,30 +43,40 @@ export declare function suppliesOpaquely(inputs: WitnessInputs, channel: InputCh
  * the keyed shape the request declares.
  */
 export declare function suppliedKeys(inputs: WitnessInputs, channel: InputChannelName): readonly string[];
-/** One channel's supplied value, for the differential comparison. */
+/**
+ * One channel's supplied value, for the differential comparison, or the
+ * sentinel above where the leg's shape carries no such channel.
+ *
+ * Reads the branch first rather than indexing the union: indexing returned
+ * `undefined` for both legs of a witness whose channel belongs to a different
+ * kind, so the two compared equal and the differential check reported "both
+ * legs supply the same value" over legs that were the wrong shape entirely.
+ * The mismatch has its own diagnosis and `checkWitnessLegality` gives it one.
+ */
 export declare function suppliedValue(inputs: WitnessInputs, channel: WitnessChannel): unknown;
 /**
  * Every channel of one set of witness inputs against the operation that will
- * receive them. All four, not only the differential channel: `planPreflight`
- * copies all four onto the `ProbeRequest` and the port sends them, so a value
- * on an unselected channel is as much an outbound value as one on the selected
- * channel.
+ * receive them, and every one of them rather than the differential channel
+ * alone: `planPreflight` copies each onto the `ProbeRequest` and the port sends
+ * them, so a value on an unselected channel is as much an outbound value as one
+ * on the selected channel. Four channels off an interface that speaks HTTP,
+ * four off a command, one off a tool call.
  *
  * The two directions have different standing, and the difference matters
  * enough to name, because the next reader will diff this against
  * `checkUndeclaredMandatoryInput` and find the two disagreeing.
  *
  * The permitted direction is that function's rule, carried over: it loops the
- * same four channels and rejects a key the operation declares in neither list.
+ * same channels and rejects a key the operation declares in neither list.
  * That is what makes `WitnessInputs`'s AD-18 promise about `header` more than a
  * comment.
  *
  * The required direction is new here, because the two shapes differ. An
  * `InputBindingChannel` is nullable, and `null` means "this step binds nothing in
  * this channel", so `checkUndeclaredMandatoryInput` skips an unbound channel and
- * asks nothing about required keys. `WitnessInputs` has all four channels as
- * concrete values, so a leg omitting a required key is a request the port cannot
- * issue. The cost is that a required header forces a literal value into the
+ * asks nothing about required keys. A `WitnessInputs` leg carries every channel
+ * of its own shape as a concrete value, so a leg omitting a required key is a
+ * request the port cannot issue. The cost is that a required header forces a literal value into the
  * contract artifact, the surface AD-18 governs; a placeholder satisfies this
  * check, and what pre-flight probes is a fixture.
  */

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

@@ -11,14 +11,17 @@
  * `malformed-operator-expression` is the closest available code because the
  * relation is illegal in its position once its operands cannot be told apart.
  */
-import { declaresNoRequestKeys, isCommandOperation, requestChannelsOf, } from '../declared-inputs.js';
+import { declaresNoRequestKeys, isCommandOperation, isMcpOperation, requestChannelsOf, } from '../declared-inputs.js';
 import { StructuralFailure } from '../failure-codes.js';
 import { operationsOf } from '../schemas/interface.js';
-import { COMMAND_WITNESS_CHANNELS, } from '../schemas/sensitivity-witness.js';
+import { API_WITNESS_CHANNELS, COMMAND_WITNESS_CHANNELS, MCP_WITNESS_CHANNELS, } from '../schemas/sensitivity-witness.js';
 import { parseEvidenceTarget } from '../seal/plan-index.js';
+import { checkExpressionEvidenceReachability, checkExpressionLegChannel, checkExpressionVolatility, } from './reachability.js';
 export { declaresNoRequestKeys };
 /** Which spelling this leg uses. `stdin` is the command shape's own key. */
 const isCommandWitnessInputs = (inputs) => 'stdin' in inputs;
+/** Which spelling this leg uses. `arguments` is the tool-call shape's one key. */
+export const isMcpWitnessInputs = (inputs) => 'arguments' in inputs;
 /**
  * The transport spelling, for the consumers that can only send one: the probe
  * port carries a method, a path template, and the four transport channels.
@@ -89,6 +92,8 @@ export function suppliedKeys(inputs, channel) {
             return Object.keys(inputs.environment);
         return [];
     }
+    if (isMcpWitnessInputs(inputs))
+        return channel === 'arguments' ? Object.keys(inputs.arguments) : [];
     if (channel === 'body')
         return bodyKeys(inputs.body);
     if (channel === 'path' || channel === 'query')
@@ -97,36 +102,87 @@ export function suppliedKeys(inputs, channel) {
         return Object.keys(inputs.header);
     return [];
 }
-/** One channel's supplied value, for the differential comparison. */
+/**
+ * The sentinel `suppliedValue` returns for a channel the leg's own shape has no
+ * key for. Distinct from `undefined`, which a leg may legitimately hold nowhere
+ * and which two mismatched legs would otherwise compare equal on.
+ */
+const CHANNEL_NOT_ON_SHAPE = Symbol('channel not on this witness leg shape');
+/** Which of the three input vocabularies a leg spells, named for a message. */
+const witnessInputsKindOf = (inputs) => {
+    if (isMcpWitnessInputs(inputs))
+        return 'tool-call';
+    if (isCommandWitnessInputs(inputs))
+        return 'command';
+    return 'transport';
+};
+/** The same question about the operation that will receive them. */
+const operationInputsKindOf = (operation) => {
+    if (isMcpOperation(operation))
+        return 'tool-call';
+    if (isCommandOperation(operation))
+        return 'command';
+    return 'transport';
+};
+/**
+ * One channel's supplied value, for the differential comparison, or the
+ * sentinel above where the leg's shape carries no such channel.
+ *
+ * Reads the branch first rather than indexing the union: indexing returned
+ * `undefined` for both legs of a witness whose channel belongs to a different
+ * kind, so the two compared equal and the differential check reported "both
+ * legs supply the same value" over legs that were the wrong shape entirely.
+ * The mismatch has its own diagnosis and `checkWitnessLegality` gives it one.
+ */
 export function suppliedValue(inputs, channel) {
-    return inputs[channel];
+    if (isMcpWitnessInputs(inputs))
+        return channel === 'arguments' ? inputs.arguments : CHANNEL_NOT_ON_SHAPE;
+    if (isCommandWitnessInputs(inputs))
+        return COMMAND_WITNESS_CHANNELS.includes(channel)
+            ? inputs[channel]
+            : CHANNEL_NOT_ON_SHAPE;
+    return API_WITNESS_CHANNELS.includes(channel)
+        ? inputs[channel]
+        : CHANNEL_NOT_ON_SHAPE;
 }
 /**
  * Every channel of one set of witness inputs against the operation that will
- * receive them. All four, not only the differential channel: `planPreflight`
- * copies all four onto the `ProbeRequest` and the port sends them, so a value
- * on an unselected channel is as much an outbound value as one on the selected
- * channel.
+ * receive them, and every one of them rather than the differential channel
+ * alone: `planPreflight` copies each onto the `ProbeRequest` and the port sends
+ * them, so a value on an unselected channel is as much an outbound value as one
+ * on the selected channel. Four channels off an interface that speaks HTTP,
+ * four off a command, one off a tool call.
  *
  * The two directions have different standing, and the difference matters
  * enough to name, because the next reader will diff this against
  * `checkUndeclaredMandatoryInput` and find the two disagreeing.
  *
  * The permitted direction is that function's rule, carried over: it loops the
- * same four channels and rejects a key the operation declares in neither list.
+ * same channels and rejects a key the operation declares in neither list.
  * That is what makes `WitnessInputs`'s AD-18 promise about `header` more than a
  * comment.
  *
  * The required direction is new here, because the two shapes differ. An
  * `InputBindingChannel` is nullable, and `null` means "this step binds nothing in
  * this channel", so `checkUndeclaredMandatoryInput` skips an unbound channel and
- * asks nothing about required keys. `WitnessInputs` has all four channels as
- * concrete values, so a leg omitting a required key is a request the port cannot
- * issue. The cost is that a required header forces a literal value into the
+ * asks nothing about required keys. A `WitnessInputs` leg carries every channel
+ * of its own shape as a concrete value, so a leg omitting a required key is a
+ * request the port cannot issue. The cost is that a required header forces a literal value into the
  * contract artifact, the surface AD-18 governs; a placeholder satisfies this
  * check, and what pre-flight probes is a fixture.
  */
 export function checkInputsAgainstShape(inputs, operation, owner, artifactPath) {
+    // The leg's shape has to be the operation's kind before any key is
+    // compared. `WitnessInputs` is a plain union with no discriminator, so a
+    // tool call's arguments parse against an operation that speaks HTTP, and
+    // the key loop below then reports the first required key as omitted, which
+    // describes a consequence of the mismatch and names the wrong field. The
+    // port's own arm says the same thing about the same pair.
+    const legKind = witnessInputsKindOf(inputs);
+    const operationKind = operationInputsKindOf(operation);
+    if (legKind !== operationKind) {
+        throw new StructuralFailure('undeclared-mandatory-input', artifactPath, `${owner} supplies ${legKind} channels to operation "${operation.operationId}", which accepts ${operationKind} channels (AD-10, AD-19)`);
+    }
     for (const { channel, shape } of requestChannelsOf(operation)) {
         if (suppliesOpaquely(inputs, channel)) {
             checkOpaqueStream(shape, channel, operation.operationId, owner, artifactPath);
@@ -218,10 +274,18 @@ const READ_CHANNELS = ['path', 'query'];
  * A command carries its inputs the same way whether or not it changes state,
  * so the marker selects nothing there and all four command channels are
  * admitted. The author picks the one their operation is actually sensitive on.
+ *
+ * A tool call is the command case with one channel: it carries its arguments
+ * the same way whichever the marker says, and there is no second channel for a
+ * marker rule to choose between. Without this arm the api rule applied and
+ * offered `path` or `query` to an operation that has neither, which left an
+ * input-bearing tool call with no legal witness at all.
  */
 const legalChannels = (operation) => {
     if (isCommandOperation(operation))
         return COMMAND_WITNESS_CHANNELS;
+    if (isMcpOperation(operation))
+        return MCP_WITNESS_CHANNELS;
     return operation.stateChangeMarker ? MUTATING_CHANNELS : READ_CHANNELS;
 };
 /**
@@ -236,11 +300,21 @@ export function checkWitnessLegality(contract) {
         if (!legal.includes(witness.channel)) {
             throw new StructuralFailure('malformed-operator-expression', `${path}.sensitivityWitness`, `channel "${witness.channel}" contradicts stateChangeMarker ${operation.stateChangeMarker} on operation "${operation.operationId}"; AD-10 selects ${legal.map((name) => `"${name}"`).join(' or ')}`);
         }
+        const [first, second] = witness.legs;
+        // The leg shape agrees with the operation's kind before anything is
+        // compared. A leg of the wrong shape carries no value on the selected
+        // channel at all, and comparing two of them found them equal and
+        // reported "not a differential", which describes a symptom of the real
+        // fault rather than the fault.
+        for (const leg of witness.legs) {
+            if (suppliedValue(leg.inputs, witness.channel) !== CHANNEL_NOT_ON_SHAPE)
+                continue;
+            throw new StructuralFailure('malformed-operator-expression', `${path}.sensitivityWitness.legs`, `leg "${leg.legId}" of witness "${witness.witnessId}" supplies inputs whose shape carries no "${witness.channel}" channel, so it cannot vary the channel operation "${operation.operationId}" declares (AD-10, AD-19)`);
+        }
         // AD-10's predicate is a differential. Two legs supplying the same values on
         // the selected channel establish nothing, and at run time that surfaces as a
         // `failed` check pointing at the fixture, when the defect is in the
         // declaration.
-        const [first, second] = witness.legs;
         if (first !== undefined &&
             second !== undefined &&
             JSON.stringify(suppliedValue(first.inputs, witness.channel)) ===
@@ -261,6 +335,20 @@ export function checkWitnessLegality(contract) {
         if (covered.length !== legIds.length) {
             throw new StructuralFailure('malformed-operator-expression', `${path}.sensitivityWitness.relation`, `the relation addresses ${covered.length} of the two legs of witness "${witness.witnessId}"; a differential that reads one leg establishes no sensitivity (AD-10)`);
         }
+        // Last, because both presume the two rules above: every root is one of
+        // this witness's own legs, so every pointer answers to this operation's
+        // own shape. `checkEvidenceReachability` never reaches a relation, since
+        // it walks oracle checks alone, and the descriptor question and the
+        // projection question are both open here.
+        const relationPath = `${path}.sensitivityWitness.relation`;
+        // Carriage first. A tailed pointer at a channel the leg does not carry is
+        // unreachable against the descriptor too, and that reason invites the
+        // author to declare structure on a channel no depth of tail would
+        // reach. The carriage reason is the accurate one at a witness for both
+        // spellings, so it is asked first.
+        checkExpressionLegChannel(witness.relation, relationPath, operation);
+        checkExpressionEvidenceReachability(witness.relation, relationPath, operation);
+        checkExpressionVolatility(witness.relation, relationPath, operation);
     });
     const reset = contract.fixtureReset;
     if (reset === null)

package/dist/core/coverage/operations.d.ts

@@ -45,7 +45,7 @@ export type ResolvedOperation = {
      * The channels a call's inputs may be keyed by. Names only: the two sites
      * that build candidate pointers need the names and never the shapes.
      */
-    readonly transportChannels: readonly InputChannelName[];
+    readonly inputChannels: readonly InputChannelName[];
     /**
      * The same channels already paired with the shapes they declare. Predicates
      * that read a declared shape take these rather than indexing the request

package/dist/core/coverage/operations.js

@@ -51,7 +51,7 @@ export function resolveOperations(contract) {
         logicalId: declared.logicalId,
         descriptor: operation.responseDescriptor,
         descriptorRoot: descriptorRootOf(operation),
-        transportChannels: inputChannelsOf(operation),
+        inputChannels: inputChannelsOf(operation),
         requestChannels: requestChannelsOf(operation),
     })));
 }

package/dist/core/coverage/relevance.d.ts

@@ -33,9 +33,9 @@ export declare function successIndicatorSeparationRelevance(contract: EvalContra
 export declare function wholeBodyRelevance(contract: EvalContract): RelevanceVerdict;
 /**
  * Rule 3: some operation declares a request key on any of its own input
- * channels, AD-19's four transport channels off an interface that speaks HTTP
- * and the four command channels off one that does not. The site is the whole
- * channel triple. A key with no
+ * channels: AD-19's four transport channels off an interface that speaks HTTP,
+ * the four command channels off a command, and the one `arguments` channel off
+ * a tool call. The site is the whole channel triple. A key with no
  * `types` entry has an absent type, a key typed `null` has AD-31's
  * indeterminate one, and both are relevant, so declaring an input and leaving
  * it untyped buys no irrelevance.

package/dist/core/coverage/relevance.js

@@ -59,9 +59,9 @@ export function wholeBodyRelevance(contract) {
 }
 /**
  * Rule 3: some operation declares a request key on any of its own input
- * channels, AD-19's four transport channels off an interface that speaks HTTP
- * and the four command channels off one that does not. The site is the whole
- * channel triple. A key with no
+ * channels: AD-19's four transport channels off an interface that speaks HTTP,
+ * the four command channels off a command, and the one `arguments` channel off
+ * a tool call. The site is the whole channel triple. A key with no
  * `types` entry has an absent type, a key typed `null` has AD-31's
  * indeterminate one, and both are relevant, so declaring an input and leaving
  * it untyped buys no irrelevance.

package/dist/core/declared-inputs.d.ts

@@ -6,7 +6,7 @@
  * because AD-10's exemption is read by two modules: the compile check that
  * enforces it and the reducer that records it.
  */
-import type { AnyOperation, CommandOperation, Operation } from './schemas/interface.ts';
+import type { AnyOperation, CommandOperation, McpOperation, Operation } from './schemas/interface.ts';
 import type { BindingChannel, InputBinding } from './schemas/plan.ts';
 import { type EvidenceChannelName, type InputChannelName } from './schemas/pointer.ts';
 import type { KeyedShapeDescriptor } from './schemas/primitives.ts';
@@ -15,8 +15,9 @@ import type { KeyedShapeDescriptor } from './schemas/primitives.ts';
  *
  * AD-19 gives every operation exactly one descriptor, and the channel that
  * descriptor describes is what makes its keys addressable. For an interface
- * that speaks HTTP that channel is the response body; a command operation
- * declares its own. One rule, three roots: every consumer that used to hard-code
+ * that speaks HTTP that channel is the response body, and a tool call's
+ * structured result lands on the same one; a command operation declares its
+ * own. One rule, several roots: every consumer that used to hard-code
  * `response-body` asks this instead.
  */
 export declare const descriptorChannelOf: (operation: AnyOperation) => EvidenceChannelName;
@@ -50,12 +51,23 @@ export type RequestChannel = {
     readonly shape: KeyedShapeDescriptor;
 };
 /**
- * Which operation shape this is. Reads `invocation` rather than a kind field,
- * because an operation does not carry its interface's kind; the two shapes are
- * distinguished by a required field only one of them declares.
+ * Which operation shape this is. Each predicate reads a required field only its
+ * own shape declares, because an operation does not carry its interface's kind.
+ *
+ * Three tests rather than one test and its negation. A negation answered `true`
+ * for every shape that was not the one it named, so the day a third shape
+ * landed the api arm would have claimed it silently and every dispatch below
+ * would have handed a tool call the four transport channels. The cost of
+ * spelling all three is that a fourth shape breaks the typecheck at each
+ * dispatch, which is where the decision belongs.
  */
 export declare const isCommandOperation: (operation: AnyOperation) => operation is CommandOperation;
-/** The same question the other way round, for the callers that filter. */
+export declare const isMcpOperation: (operation: AnyOperation) => operation is McpOperation;
+/**
+ * Repaired to ask its own question positively. Its two callers filter a mixed
+ * inventory down to the shape that declares a method and a path template, and a
+ * negation would have handed them every tool call as well.
+ */
 export declare const isApiOperation: (operation: AnyOperation) => operation is Operation;
 /**
  * The operation's input channels paired with the shapes they declare.
@@ -63,7 +75,7 @@ export declare const isApiOperation: (operation: AnyOperation) => operation is O
  * Callers take the pairs rather than a channel list they then index the
  * request shape with. Indexing is what breaks under the operation union:
  * TypeScript cannot prove that a channel name drawn from one kind's tuple is a
- * key of the other kind's shape, and both ways around that are casts. Pairing
+ * key of another kind's shape, and both ways around that are casts. Pairing
  * dereferences the union once, here.
  */
 export declare function requestChannelsOf(operation: AnyOperation): readonly RequestChannel[];
@@ -92,4 +104,4 @@ export declare function boundChannelsOf(binding: InputBinding): readonly {
 export declare function declaresNoRequestKeys(operation: AnyOperation): boolean;
 /** Whether no channel declares a required key. */
 export declare function declaresNoRequiredKeys(operation: AnyOperation): boolean;
-export type { AnyOperation, CommandOperation, Operation };
+export type { AnyOperation, CommandOperation, McpOperation, Operation };

package/dist/core/declared-inputs.js

@@ -1,20 +1,30 @@
-import { COMMAND_CHANNELS, INPUT_CHANNELS, TRANSPORT_CHANNELS, } from './schemas/pointer.js';
+import { COMMAND_CHANNELS, INPUT_CHANNELS, MCP_CHANNELS, TRANSPORT_CHANNELS, } from './schemas/pointer.js';
+// The channel each tagged descriptor-channel member names. Keyed on the tag, so
+// admitting the prose half of a tool result later fails the typecheck here.
+const MCP_DESCRIPTOR_CHANNELS = {
+    'structured-result': 'response-body',
+};
 /**
  * Which output channel the operation's one response descriptor describes.
  *
  * AD-19 gives every operation exactly one descriptor, and the channel that
  * descriptor describes is what makes its keys addressable. For an interface
- * that speaks HTTP that channel is the response body; a command operation
- * declares its own. One rule, three roots: every consumer that used to hard-code
+ * that speaks HTTP that channel is the response body, and a tool call's
+ * structured result lands on the same one; a command operation declares its
+ * own. One rule, several roots: every consumer that used to hard-code
  * `response-body` asks this instead.
  */
 export const descriptorChannelOf = (operation) => {
-    if (!isCommandOperation(operation))
-        return 'response-body';
-    const { descriptorChannel } = operation;
-    return descriptorChannel.kind === 'stream'
-        ? descriptorChannel.channel
-        : 'artifact';
+    if (isCommandOperation(operation)) {
+        const { descriptorChannel } = operation;
+        return descriptorChannel.kind === 'stream'
+            ? descriptorChannel.channel
+            : 'artifact';
+    }
+    if (isMcpOperation(operation)) {
+        return MCP_DESCRIPTOR_CHANNELS[operation.descriptorChannel.kind];
+    }
+    return 'response-body';
 };
 /**
  * Which artifact the descriptor describes, or `null` when it describes a
@@ -25,6 +35,8 @@ export const descriptorChannelOf = (operation) => {
 export const descriptorArtifactOf = (operation) => {
     if (!isCommandOperation(operation))
         return null;
+    // Only a command operation nominates a file. A tool call and an HTTP
+    // response both describe a channel the transport always produces.
     const { descriptorChannel } = operation;
     return descriptorChannel.kind === 'artifact'
         ? descriptorChannel.artifactId
@@ -51,20 +63,31 @@ export const targetsDescribedChannel = (operation, target) => {
 /** Every artifact identifier the operation declares it writes. */
 export const declaredArtifactsOf = (operation) => isCommandOperation(operation) ? operation.artifacts : [];
 /**
- * Which operation shape this is. Reads `invocation` rather than a kind field,
- * because an operation does not carry its interface's kind; the two shapes are
- * distinguished by a required field only one of them declares.
+ * Which operation shape this is. Each predicate reads a required field only its
+ * own shape declares, because an operation does not carry its interface's kind.
+ *
+ * Three tests rather than one test and its negation. A negation answered `true`
+ * for every shape that was not the one it named, so the day a third shape
+ * landed the api arm would have claimed it silently and every dispatch below
+ * would have handed a tool call the four transport channels. The cost of
+ * spelling all three is that a fourth shape breaks the typecheck at each
+ * dispatch, which is where the decision belongs.
  */
 export const isCommandOperation = (operation) => 'invocation' in operation;
-/** The same question the other way round, for the callers that filter. */
-export const isApiOperation = (operation) => !isCommandOperation(operation);
+export const isMcpOperation = (operation) => 'toolName' in operation;
+/**
+ * Repaired to ask its own question positively. Its two callers filter a mixed
+ * inventory down to the shape that declares a method and a path template, and a
+ * negation would have handed them every tool call as well.
+ */
+export const isApiOperation = (operation) => 'method' in operation;
 /**
  * The operation's input channels paired with the shapes they declare.
  *
  * Callers take the pairs rather than a channel list they then index the
  * request shape with. Indexing is what breaks under the operation union:
  * TypeScript cannot prove that a channel name drawn from one kind's tuple is a
- * key of the other kind's shape, and both ways around that are casts. Pairing
+ * key of another kind's shape, and both ways around that are casts. Pairing
  * dereferences the union once, here.
  */
 export function requestChannelsOf(operation) {
@@ -74,6 +97,12 @@ export function requestChannelsOf(operation) {
             shape: operation.requestShape[channel],
         }));
     }
+    if (isMcpOperation(operation)) {
+        return MCP_CHANNELS.map((channel) => ({
+            channel,
+            shape: operation.requestShape[channel],
+        }));
+    }
     return TRANSPORT_CHANNELS.map((channel) => ({
         channel,
         shape: operation.requestShape[channel],
@@ -85,7 +114,13 @@ export function requestShapeOf(operation, channel) {
         ?.shape;
 }
 /** The channel names an operation of this kind may declare inputs on. */
-export const inputChannelsOf = (operation) => isCommandOperation(operation) ? COMMAND_CHANNELS : TRANSPORT_CHANNELS;
+export const inputChannelsOf = (operation) => {
+    if (isCommandOperation(operation))
+        return COMMAND_CHANNELS;
+    if (isMcpOperation(operation))
+        return MCP_CHANNELS;
+    return TRANSPORT_CHANNELS;
+};
 /**
  * A step's bound channels paired with what each binds, for the same reason
  * `requestChannelsOf` pairs: `InputBinding` is a union and a channel name

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

@@ -50,12 +50,13 @@ export declare function makeResolveOperand(stepObservations: Readonly<Record<str
  */
 export declare function referenceSetKeysOf(contract: EvalContract): ReferenceSetKeys;
 /**
- * Only `response-body` can ever answer `true` (AD-19: `collectionLocations`
- * is the only declared-collection surface, scoped to the body alone). The
- * `PlanIndex` builds lazily on first call unless the caller supplies one,
- * since a schema-admitted duplicate step or operation id would make building
- * it eagerly throw before this function ever runs. Uses `stepOf`/`operationOf`
- * rather than `resolveStep`/`resolveOperation`: those throw on a miss, which
- * would break this function's always-returns-a-boolean contract.
+ * Answers `true` only for a pointer at the channel the invoked operation's own
+ * response descriptor describes, since that is where AD-19 puts a declared
+ * collection. The `PlanIndex` builds lazily on first call unless the caller
+ * supplies one, since a schema-admitted duplicate step or operation id would
+ * make building it eagerly throw before this function ever runs. Uses
+ * `stepOf`/`operationOf` rather than `resolveStep`/`resolveOperation`: those
+ * throw on a miss, which would break this function's always-returns-a-boolean
+ * contract.
  */
 export declare function makePointerDenotesCollection(contract: EvalContract, providedIndex?: PlanIndex): PointerDenotesCollection;

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

@@ -98,13 +98,20 @@ export function channelRoot(observation, target) {
         case 'exit-code':
             return observation.exitCode;
         case 'call-inputs': {
-            const { transportChannel } = target;
-            if (transportChannel === null) {
-                // parseEvidenceTarget sets transportChannel exactly when the
+            const { inputChannel } = target;
+            if (inputChannel === null) {
+                // parseEvidenceTarget sets inputChannel exactly when the
                 // channel is 'call-inputs', so this throw should never fire.
-                throw new TypeError('call-inputs evidence target carries no transport channel');
+                throw new TypeError('call-inputs evidence target carries no input channel');
             }
-            return observation.callInputs[transportChannel];
+            // A direct read: `ObservedCallInputs` declares one key per member of
+            // `INPUT_CHANNELS`, so every channel the grammar parses has a key
+            // here and `null` means the channel carried nothing. A tenth
+            // channel joining the vocabulary fails the typecheck at this line.
+            // The lookup helper this replaced answered absent for a missing
+            // key, which was correct while the two widths disagreed and is a
+            // silent answer now that they do not.
+            return observation.callInputs[inputChannel];
         }
         case 'artifact': {
             const { artifactId } = target;
@@ -176,13 +183,14 @@ function tokensEqual(a, b) {
     return a.length === b.length && a.every((token, index) => token === b[index]);
 }
 /**
- * Only `response-body` can ever answer `true` (AD-19: `collectionLocations`
- * is the only declared-collection surface, scoped to the body alone). The
- * `PlanIndex` builds lazily on first call unless the caller supplies one,
- * since a schema-admitted duplicate step or operation id would make building
- * it eagerly throw before this function ever runs. Uses `stepOf`/`operationOf`
- * rather than `resolveStep`/`resolveOperation`: those throw on a miss, which
- * would break this function's always-returns-a-boolean contract.
+ * Answers `true` only for a pointer at the channel the invoked operation's own
+ * response descriptor describes, since that is where AD-19 puts a declared
+ * collection. The `PlanIndex` builds lazily on first call unless the caller
+ * supplies one, since a schema-admitted duplicate step or operation id would
+ * make building it eagerly throw before this function ever runs. Uses
+ * `stepOf`/`operationOf` rather than `resolveStep`/`resolveOperation`: those
+ * throw on a miss, which would break this function's always-returns-a-boolean
+ * contract.
  */
 export function makePointerDenotesCollection(contract, providedIndex) {
     let index = providedIndex;
@@ -200,12 +208,11 @@ export function makePointerDenotesCollection(contract, providedIndex) {
         const operation = anyOperationOf(getIndex(), step.operationId);
         if (operation === undefined)
             return false;
-        // The channel is tested against the operation's own descriptor rather
-        // than against `response-body`. AD-4's empty-collection resolution
-        // applies to whichever channel an operation says carries its declared
-        // collections, and hard-coding the body left it inapplicable to every
-        // command contract: a quantifier over an empty declared collection
-        // resolved `false` instead of `insufficient-evidence`.
+        // The channel has to be the one this operation's descriptor describes.
+        // Hard-coding `response-body` here left AD-4's empty-collection
+        // resolution inapplicable to every command contract: a quantifier over
+        // an empty declared collection resolved `false` where the rule says
+        // `insufficient-evidence`.
         if (!targetsDescribedChannel(operation, target))
             return false;
         const { collectionLocations } = operation.responseDescriptor;