eval-quality 1.4.2 → 2.0.0

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

@@ -22,7 +22,7 @@ export const ApiWitnessInputs = z
 })
     .meta({
     id: 'WitnessInputs',
-    description: "One probe leg's supplied inputs, keyed by AD-19 transport channel, in the spelling the environment-probe port accepts. Shared by both witness kinds and by the fixture reset, so the export carries it once.",
+    description: "One probe leg's supplied inputs, keyed by AD-19 transport channel, in the spelling the environment-probe port accepts. The transport branch of the union every leg shape takes: a sensitivity leg, a manifestation witness, and the fixture reset.",
 });
 /**
  * The same, for a leg supplied to a command-kind operation. `stdin` is a
@@ -50,7 +50,19 @@ export const CommandWitnessInputs = z.strictObject({
     stdin: ProbeRequestStdin,
 });
 /**
- * Either spelling. A plain union rather than a discriminated one for the same
+ * The same, for a leg supplied to a tool call. One key, because a tool call
+ * carries an arguments object and nothing else, and a JSON object rather than a
+ * tagged value because an argument-less call supplies `{}` and has no absent
+ * spelling to tell apart from a JSON null.
+ */
+// Bare, with no `.meta({ id })`, on the reason the command branch above records:
+// two `$ref`'d definitions under one `anyOf` report `#/required` at the same
+// instance path and AD-13's mutation sweep cannot attribute the deletion.
+export const McpWitnessInputs = z.strictObject({
+    arguments: JsonObjectValue,
+});
+/**
+ * Any spelling. A plain union rather than a discriminated one for the same
  * reason `InputBinding` is: the leg names an operation and the kind of the
  * interface declaring it lives in another subtree, so no discriminator is
  * available to the schema and the agreement is a compile-time check.
@@ -60,13 +72,18 @@ export const CommandWitnessInputs = z.strictObject({
  * took it from 0.3.0 and the other two followed in 1.3.0, since the transport
  * spelling left a seeded defect against a command-line system under test
  * unrepresentable. The reach is the port's: all three legs are issued through
- * the environment-probe port, whose `ProbeRequest` is itself a union of
- * `ApiProbeRequest` and `CommandProbeRequest`, and `preflight/plan.ts` admits
- * `api` and `cli`, rejecting `web` and `mcp` under `unsupported-interface-kind`.
- * A leg shape narrower than the port it feeds leaves a kind the adapter can run
- * with no way to declare a leg for it.
+ * the environment-probe port, whose `ProbeRequest` carries one member per kind
+ * `isSupportedInterfaceKind` admits, and `preflight/plan.ts` gates on that same
+ * predicate. The invariant is the count rather than the list: a leg shape
+ * narrower than the port it feeds leaves a kind the adapter can run with no way
+ * to declare a leg for it, so this union takes one member per port member and
+ * opening a kind adds one to each.
  */
-export const WitnessInputs = z.union([ApiWitnessInputs, CommandWitnessInputs]);
+export const WitnessInputs = z.union([
+    ApiWitnessInputs,
+    CommandWitnessInputs,
+    McpWitnessInputs,
+]);
 /**
  * Half a witness pair. `legId` roots the relation's pointers, which address this
  * leg's response as `/interactions/{legId}/response-body/...`, so it shares one
@@ -92,9 +109,15 @@ export const COMMAND_WITNESS_CHANNELS = [
     'environment',
     'stdin',
 ];
+// A tool call's one channel. AD-10's marker rule decides nothing here for the
+// reason it decides nothing for a command: a tool call carries its inputs the
+// same way whether or not it changes state. With one channel there is nothing
+// left for the rule to select, so both marker values admit it.
+export const MCP_WITNESS_CHANNELS = ['arguments'];
 export const WITNESS_CHANNELS = [
     ...API_WITNESS_CHANNELS,
     ...COMMAND_WITNESS_CHANNELS,
+    ...MCP_WITNESS_CHANNELS,
 ];
 export const WitnessChannel = z.enum(WITNESS_CHANNELS);
 /**
@@ -140,7 +163,7 @@ export const ManifestationWitness = z.strictObject({
     legId: Identifier,
     interfaceId: Identifier,
     operationId: Identifier,
-    inputs: WitnessInputs,
+    inputs: WitnessInputs.describe("The probe's `schemaVersion` 3 -> 4 BREAKING bump under AD-11, whose rule is that removing or retyping is breaking. The union gained a third leg shape, one key over a tool call's arguments, so a witness leg against a tool call is expressible. The matching defect signature is a separate shape and version 5 is where it landed, so a version-4 probe declares a witness leg against a tool call and no signature for the defect that leg exercises. Against version 4 every version-3 probe's own bytes still parse, since the widening adds a branch and narrows none; version 5 narrows two shapes and is where a version-3 or version-4 probe stops parsing."),
     relation: Expression,
 });
 /**

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

@@ -30,7 +30,7 @@ export type CapturedResolution = {
  * JSON-encoded rather than delimiter-joined, since a parameter key is arbitrary
  * caller-supplied text and could contain any separator.
  */
-export declare function bindingSiteKey(stepId: string, transportChannel: InputChannelName, key: string): string;
+export declare function bindingSiteKey(stepId: string, inputChannel: InputChannelName, key: string): string;
 /**
  * Resolves one captured pointer against the record.
  *

package/dist/core/score/bindings.js

@@ -27,8 +27,8 @@ const ABSENT_RESOLUTION = { status: 'absent' };
  * JSON-encoded rather than delimiter-joined, since a parameter key is arbitrary
  * caller-supplied text and could contain any separator.
  */
-export function bindingSiteKey(stepId, transportChannel, key) {
-    return JSON.stringify([stepId, transportChannel, key]);
+export function bindingSiteKey(stepId, inputChannel, key) {
+    return JSON.stringify([stepId, inputChannel, key]);
 }
 /**
  * Resolves one captured pointer against the record.
@@ -111,7 +111,7 @@ export function resolveCapturedBindings(interactionPlan, index, observations) {
             if (step === undefined)
                 continue;
             for (const capture of capturedBindings(step)) {
-                resolved.set(bindingSiteKey(stepId, capture.transportChannel, capture.key), resolveCapturedValue(capture.pointer, index, observations, resolved));
+                resolved.set(bindingSiteKey(stepId, capture.inputChannel, capture.key), resolveCapturedValue(capture.pointer, index, observations, resolved));
             }
         }
     }
@@ -161,7 +161,7 @@ export function jsonTypeOf(value) {
 function capturedFloor(step, resolved) {
     let floor = null;
     for (const capture of capturedBindings(step)) {
-        const resolution = resolved.get(bindingSiteKey(step.stepId, capture.transportChannel, capture.key));
+        const resolution = resolved.get(bindingSiteKey(step.stepId, capture.inputChannel, capture.key));
         if (resolution === undefined || resolution.status !== 'resolved')
             return null;
         floor =

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

@@ -30,11 +30,13 @@ export type QualificationResult = {
 };
 /**
  * Resolves a signature's home operation against a contract's operation
- * inventory, comparing method plus path template with parameter names erased
- * first, so a corpus signature on `/notes/{id}` binds a contract declaring
- * `/notes/{noteId}`. A post-erasure collision inside one contract has already
- * failed compilation under `duplicate-operation-signature`, so the first match
- * is the only match for any contract that compiled.
+ * inventory, comparing the transport identity each renders inside its own shape
+ * family. Off an interface that speaks HTTP that identity is a method plus a
+ * path template with parameter names erased first, so a corpus signature on
+ * `/notes/{id}` binds a contract declaring `/notes/{noteId}`. A collision inside
+ * one contract and one family has already failed compilation under
+ * `duplicate-operation-signature`, so the first match is the only match for any
+ * contract that compiled.
  */
 export declare function resolveHomeOperation(signature: DefectSignature, interfaces: readonly PermittedInterface[]): AnyOperation | null;
 /**

package/dist/core/score/qualification.js

@@ -15,7 +15,7 @@
  * `Error`.
  */
 import { checkExpressionOperandLegality, checkExpressionQuantifierNesting, checkExpressionQuantifierOverNonCollection, checkExpressionRegexConstructs, walkExpression, } from '../compile/expression-legality.js';
-import { anyOperationSignature, commandSignature, operationSignature, } from '../compile/interface-inventory.js';
+import { anyOperationSignature, commandSignature, isSupportedInterfaceKind, mcpSignature, operationSignature, SUPPORTED_KINDS_CLAUSE, signatureFamilyOf, } from '../compile/interface-inventory.js';
 import { checkExpressionBoundElementScope, checkExpressionEvidenceReachability, forEachExpressionPointer, } from '../compile/reachability.js';
 import { requestShapeOf } from '../declared-inputs.js';
 import { StructuralFailure } from '../failure-codes.js';
@@ -49,26 +49,46 @@ export const QUALIFICATION_FAILURES = [
     'condition-quantifier-over-non-collection',
     'condition-bound-element-outside-quantifier',
 ];
+/**
+ * The transport identity a signature declares, in its own kind's spelling. All
+ * four kinds render one now: `mcp` renders the published tool name its own
+ * branch declares, which is what `McpOperation` renders on the contract side.
+ *
+ * A switch with no default arm, so a fifth kind fails the typecheck here rather
+ * than inheriting the api arm the way a two-way test let `mcp` do.
+ */
+const declaredIdentityOf = (signature) => {
+    switch (signature.interfaceKind) {
+        case 'cli':
+            return commandSignature(signature);
+        case 'mcp':
+            return mcpSignature(signature);
+        case 'api':
+        case 'web':
+            return operationSignature(signature);
+    }
+};
 /**
  * Resolves a signature's home operation against a contract's operation
- * inventory, comparing method plus path template with parameter names erased
- * first, so a corpus signature on `/notes/{id}` binds a contract declaring
- * `/notes/{noteId}`. A post-erasure collision inside one contract has already
- * failed compilation under `duplicate-operation-signature`, so the first match
- * is the only match for any contract that compiled.
+ * inventory, comparing the transport identity each renders inside its own shape
+ * family. Off an interface that speaks HTTP that identity is a method plus a
+ * path template with parameter names erased first, so a corpus signature on
+ * `/notes/{id}` binds a contract declaring `/notes/{noteId}`. A collision inside
+ * one contract and one family has already failed compilation under
+ * `duplicate-operation-signature`, so the first match is the only match for any
+ * contract that compiled.
  */
 export function resolveHomeOperation(signature, interfaces) {
-    // The identity is compared within its own kind. A signature declaring a
-    // method and a path template can only name an operation declaring the same
-    // pair, and one declaring an invocation can only name an operation
-    // declaring one; comparing the rendered strings across kinds would let
+    // The identity is compared within its own shape family. A signature
+    // declaring a method and a path template can only name an operation
+    // declaring the same pair, one declaring an invocation can only name an
+    // operation declaring one, and one declaring a tool name can only name a
+    // tool; comparing the rendered strings across families would let
     // `GET /notes` collide with an executable literally named that.
-    const command = signature.interfaceKind === 'cli';
-    const wanted = command
-        ? commandSignature(signature)
-        : operationSignature(signature);
+    const wanted = declaredIdentityOf(signature);
+    const family = signatureFamilyOf(signature.interfaceKind);
     for (const iface of interfaces) {
-        if ((iface.kind === 'cli') !== command)
+        if (signatureFamilyOf(iface.kind) !== family)
             continue;
         for (const operation of operationsOf(iface)) {
             if (anyOperationSignature(operation) === wanted)
@@ -86,8 +106,46 @@ export function resolveHomeOperation(signature, interfaces) {
 // a channel joins the enum, so a new channel would have gone unassigned and
 // silently answered "no" to both questions below.
 const RESPONSE_SIDE = new Set(RESPONSE_SIDE_CHANNELS);
-/** The channels a signature of this kind can never manifest in. */
-const foreignChannels = (kind) => new Set(kind === 'cli' ? API_RESPONSE_CHANNELS : COMMAND_RESPONSE_CHANNELS);
+/**
+ * The channels a signature of this kind can never manifest in.
+ *
+ * Three arms rather than two. A tool call produces neither the command response
+ * channels nor `response-headers`: it carries its structured result on
+ * `response-body` and its error flag on `response-status`, which is the same
+ * answer `checkExpressionLegChannel` and `evaluateReachabilityAgainstOperation`
+ * give at compile. A two-way ternary put `mcp` on the api arm and left
+ * `response-headers` admitted here while compile refused it, which is two
+ * sources of truth about what a tool call produces.
+ */
+const foreignChannels = (kind) => {
+    switch (kind) {
+        case 'cli':
+            return new Set(API_RESPONSE_CHANNELS);
+        case 'mcp':
+            return new Set([...COMMAND_RESPONSE_CHANNELS, 'response-headers']);
+        case 'api':
+        case 'web':
+            return new Set(COMMAND_RESPONSE_CHANNELS);
+    }
+};
+// `condition-text-channel-on-api` fires for any channel the declared kind
+// cannot produce, `response-headers` on a tool call included, so the name is
+// narrower than the rule. It stays: renaming moves an AD-5 registry row, a
+// `QUALIFICATION_FAILURES` member, every fixture naming it, and the published
+// census, with no behaviour behind any of it. Recorded here as a known
+// imprecision so a reader of the closed table is not surprised by it.
+/** How a detail string names the sort of interface a signature declares. */
+const interfacePhraseOf = (kind) => {
+    switch (kind) {
+        case 'cli':
+            return 'an interface behind a command';
+        case 'mcp':
+            return 'a tool call';
+        case 'api':
+        case 'web':
+            return 'an api interface';
+    }
+};
 const probePath = (probe, tail) => `Probe[probeId=${probe.probeId}]${tail}`;
 /**
  * Which routes this probe's class and control status admit. An empty list is
@@ -262,7 +320,7 @@ function checkOperandsAndCollectChannels(probe, signature, failures) {
             failures.push({
                 code: 'condition-text-channel-on-api',
                 artifactPath: `${conditionPath}${path}`,
-                detail: `"${pointer}" addresses ${target.channel}, which ${signature.interfaceKind === 'cli' ? 'an interface behind a command' : 'an api interface'} never produces (AD-19, AD-26)`,
+                detail: `"${pointer}" addresses ${target.channel}, which ${interfacePhraseOf(signature.interfaceKind)} never produces (AD-19, AD-26)`,
             });
         }
     });
@@ -343,7 +401,8 @@ function checkSelectorKeys(probe, signature, operation, failures) {
  * unchecked would make an unchecked field load-bearing. On an `api` signature
  * the three text channels are rejected for the same reason a pointer into one
  * is: an api interface never produces them, which is the same rule the pointer
- * walk applies, read on the declaration too.
+ * walk applies, read on the declaration too. A tool call rejects those three and
+ * `response-headers`, since it produces neither.
  */
 function checkObservableChannel(probe, signature, failures) {
     const path = probePath(probe, '.defectSignature.observableChannel');
@@ -359,7 +418,7 @@ function checkObservableChannel(probe, signature, failures) {
         failures.push({
             code: 'condition-text-channel-on-api',
             artifactPath: path,
-            detail: `declares observableChannel "${signature.observableChannel}", which ${signature.interfaceKind === 'cli' ? 'an interface behind a command' : 'an api interface'} never produces (AD-19, AD-26)`,
+            detail: `declares observableChannel "${signature.observableChannel}", which ${interfacePhraseOf(signature.interfaceKind)} never produces (AD-19, AD-26)`,
         });
     }
 }
@@ -589,12 +648,22 @@ export function qualifyProbe(probe, homeOperation) {
         }
     }
     if (signature !== null) {
-        if (signature.interfaceKind !== 'api' &&
-            signature.interfaceKind !== 'cli') {
+        // The same tuple the compile and pre-flight gates read, so what a
+        // contract may declare and what a signature may declare against cannot
+        // disagree. This was the fourth transcription of the pair and the last.
+        //
+        // The coupling is deliberate and it is not free: the two questions can
+        // legitimately differ, and they did for one release, when the contract
+        // gates opened for `mcp` while this one stayed shut because the kind had
+        // no signature branch to declare. Opening a kind contract-side now opens
+        // it here too. A future kind that needs the gap back gets its own
+        // predicate beside `isSupportedInterfaceKind` rather than a re-spelled
+        // condition, so the divergence stays a named decision.
+        if (!isSupportedInterfaceKind(signature.interfaceKind)) {
             failures.push({
                 code: 'signature-interface-kind-unsupported',
                 artifactPath: probePath(probe, '.defectSignature.interfaceKind'),
-                detail: `"${signature.interfaceKind}" declares a method and a path template with no per-kind semantics behind them; the kinds stay in the enum so unsupported-interface-kind stays fireable contract-side (AD-19)`,
+                detail: `"${signature.interfaceKind}" has no probe semantics in this version: it declares a method and a path template with no per-kind semantics behind them, and no operation shape of its own for a signature to bind. It stays in the enum so unsupported-interface-kind stays fireable contract-side; ${SUPPORTED_KINDS_CLAUSE} admitted here (AD-19)`,
             });
         }
         checkObservableChannel(probe, signature, failures);

package/dist/core/score/score.js

@@ -203,7 +203,7 @@ function trialSetDisagreementsOf(trials) {
  * 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.
+ * does compare `mode`, `evaluatorRecommendation`, and `runId` 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

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

@@ -5,7 +5,7 @@
  * 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 { boundChannelsOf, isCommandOperation, isMcpOperation, } from '../declared-inputs.js';
 import { StructuralFailure } from '../failure-codes.js';
 import { anyOperationOf, parseEvidenceTarget, resolveStep, } from './plan-index.js';
 function resolveEvidenceTarget(pointer, index) {
@@ -35,17 +35,20 @@ function joinWithAnd(items) {
 // `buildPlanIndex` already rejects a duplicate `operationId` across
 // 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.
+// withholds the operation inventory from the brief, so a method and a path
+// template, an executable and a subcommand path, and a tool name are all
+// withheld from an evaluator alike.
 //
 // 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) {
     const name = operation.operationId.split('-').join(' ');
-    return isCommandOperation(operation)
-        ? `the ${name} command`
-        : `the ${name} endpoint`;
+    if (isCommandOperation(operation))
+        return `the ${name} command`;
+    if (isMcpOperation(operation))
+        return `the ${name} tool`;
+    return `the ${name} endpoint`;
 }
 const ESCALATION_LEVELS = [
     'generic',
@@ -57,23 +60,23 @@ const ESCALATION_LEVELS = [
 // stays permutation-invariant. `boundChannelsOf` supplies the channel order.
 function bindingEntries(step) {
     const entries = [];
-    for (const { channel: transportChannel, bound: map } of boundChannelsOf(step.inputBinding)) {
+    for (const { channel: inputChannel, bound: map } of boundChannelsOf(step.inputBinding)) {
         if (map === null)
             continue;
         for (const key of Object.keys(map).sort()) {
             const value = map[key];
             if (value !== undefined)
-                entries.push({ transportChannel, key, value });
+                entries.push({ inputChannel, key, value });
         }
     }
     return entries;
 }
-// The transport channel is part of the rendered name as well as the sort
+// The input channel is part of the rendered name as well as the sort
 // key: two bindings can share a parameter name across channels (path.id and
 // query.id), and without the qualifier both would render as "the supplied
 // id", hiding two different bindings behind identical text.
 function entryName(entry) {
-    return `${entry.transportChannel} ${entry.key}`;
+    return `${entry.inputChannel} ${entry.key}`;
 }
 function isTypeViolating(value) {
     return 'matcher' in value && value.matcher === 'type-violating';
@@ -411,17 +414,17 @@ function localTargetPhrase(target) {
         case 'exit-code':
             return 'its exit code';
         case 'call-inputs': {
-            if (target.transportChannel === null) {
+            if (target.inputChannel === null) {
                 // Unreachable: `parseEvidenceTarget` sets this exactly when the
                 // channel is 'call-inputs'.
-                throw new TypeError('call-inputs evidence target carries no transport channel');
+                throw new TypeError('call-inputs evidence target carries no input channel');
             }
-            // The transport channel is named here too, not only in the no-tail
+            // The input channel is named here too, not only in the no-tail
             // fallback below: same path.id / query.id collision `entryName`
             // above guards against.
             return field !== null
-                ? `the ${target.transportChannel} ${field} value you sent`
-                : `the ${target.transportChannel} you sent`;
+                ? `the ${target.inputChannel} ${field} value you sent`
+                : `the ${target.inputChannel} you sent`;
         }
         case 'response-body':
             return field !== null
@@ -448,7 +451,7 @@ function localTargetPhrase(target) {
                 // channel is 'artifact'.
                 throw new TypeError('artifact evidence target names no artifact');
             }
-            // The artifact is named for the same reason the transport channel
+            // The artifact is named for the same reason the input channel
             // is: two files can carry the same field name, and an evaluator
             // reading "its findings field" twice cannot tell which file it
             // means.
@@ -472,7 +475,7 @@ function fullTargetPhrase(resolved, siblingsOf, index) {
 function channelSignature(target) {
     return JSON.stringify([
         target.channel,
-        target.transportChannel,
+        target.inputChannel,
         target.artifactId,
         target.tail,
     ]);

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

@@ -1,5 +1,5 @@
 /** resolves a pointer to its step and operation; nothing about reachability. */
-import type { AnyOperation, CommandOperation, InterfaceKindName, Operation, PermittedInterface } from '../schemas/interface.ts';
+import type { AnyOperation, CommandOperation, InterfaceKindName, McpOperation, Operation, PermittedInterface } from '../schemas/interface.ts';
 import type { InteractionStep } from '../schemas/plan.ts';
 import { type EvidenceChannelName, type InputChannelName } from '../schemas/pointer.ts';
 /**
@@ -17,13 +17,13 @@ export declare const decodeTail: (tailSource: string) => readonly string[];
 export type EvidenceTarget = {
     stepId: string;
     channel: EvidenceChannelName;
-    transportChannel: InputChannelName | null;
+    inputChannel: InputChannelName | null;
     artifactId: string | null;
     tail: readonly string[];
 };
 /**
  * Parses one `InteractionPointer` string (`INTERACTION_POINTER_PATTERN` in
- * `pointer.ts`) into its step id, channel, transport channel, and tail, using
+ * `pointer.ts`) into its step id, channel, input channel, and tail, using
  * the schema's own channel partition so this accepts exactly what
  * `InteractionPointer.safeParse` accepts. A should-never-happen precondition
  * violation throws `TypeError`, per `digest.ts`'s precedent.
@@ -38,14 +38,15 @@ export declare function parseEvidenceTarget(pointer: string): EvidenceTarget;
  *
  * `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.
+ * union would retype seventeen files at once. A command operation and a tool
+ * call each resolve to `undefined` from it and to a value from their own
+ * accessor, 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;
+    mcpOperationOf: (operationId: string) => McpOperation | undefined;
     interfaceKindOf: (operationId: string) => InterfaceKindName | undefined;
     stepsUsing: (operationId: string) => readonly InteractionStep[];
 };
@@ -70,9 +71,17 @@ export declare function buildPlanIndex(interactionPlan: readonly InteractionStep
 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
+ * fields all three 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;
+/**
+ * Resolves an operation id through the index or throws. See `resolveStep`.
+ *
+ * Reads all three maps. It read `operationOf` alone, so it threw for a command
+ * operation and then for a tool call with the message "the permitted interfaces
+ * do not declare it", which is false: they declare it, and a different accessor
+ * holds it. Callers narrow with the operation predicates in
+ * `core/declared-inputs.ts`.
+ */
+export declare function resolveOperation(index: PlanIndex, operationId: string): AnyOperation;