eval-quality 0.2.0 → 0.3.0

package/dist/core/schemas/interface.js

@@ -85,7 +85,8 @@ export const PathTemplate = z
     .string()
     .regex(PATH_TEMPLATE_PATTERN)
     .describe('A path template whose parameters are spelled `{name}` in braces. The `:name` spelling is rejected: AD-40 resolves a defect signature by comparing method and path template, and that comparison is not implementable against an unstated syntax.');
-export const Operation = z.strictObject({
+export const Operation = z
+    .strictObject({
     operationId: Identifier,
     method: HttpMethod,
     pathTemplate: PathTemplate,
@@ -96,6 +97,91 @@ export const Operation = z.strictObject({
     responseDescriptor: ResponseDescriptor,
     volatilePointers: z.array(DescriptorPointer),
     sensitivityWitness: SensitivityWitness.nullable().describe('AD-10, mandatory per declared operation rather than per interface. `null` is legal only for an operation declaring no keys in any request channel; AD-10 exempts that operation and requires the exemption to be recorded, which pre-flight does as an `exempt` check. An input-bearing operation declaring `null` fails a strict compilation under `undeclared-mandatory-input`, alongside the other declaration-completeness check that code already gates.'),
+})
+    .meta({
+    id: 'Operation',
+    description: "AD-19's per-operation declaration inventory for an interface that speaks HTTP. Carried by the `api`, `web`, and `mcp` branches alike, so the export names it once instead of inlining three copies that could drift apart.",
+});
+/**
+ * AD-35 applied to a command: the operation names a logical executable and the
+ * caller maps it to something runnable outside the contract. `Identifier`'s
+ * charset admits no slash, dot, or colon, so `/usr/local/bin/tool`, `./tool`,
+ * and `http://host/tool` are parse errors rather than compile findings. That is
+ * what makes AD-35 structural here instead of advisory.
+ *
+ * The subcommand path is a list of segments rather than one string for the
+ * reason `PathTemplate` spells parameters in braces and nothing else: AD-40
+ * compares identities as segments, and a single string would force two
+ * implementations to agree on a separator no field declares.
+ */
+export const CommandInvocation = z.strictObject({
+    executable: Identifier.describe('A logical executable name, never a filesystem path, a URL, a host, or a port (AD-35). The caller maps it to an authorized target through configuration outside the contract.'),
+    subcommandPath: z
+        .array(Identifier)
+        .describe('The subcommand segments after the executable, outermost first. Empty is legal and means the executable is invoked with no subcommand.'),
+});
+/**
+ * The command counterpart of `RequestShape`, built as a four-key strict object
+ * for the reason the comment above `RequestShape` gives: a record over a
+ * channel enum demands every member at parse time, and the partial spelling
+ * that would relax it is the one the Consistency Conventions ban.
+ */
+export const CommandRequestShape = z.strictObject({
+    argument: KeyedShapeDescriptor.describe("Positional arguments, keyed by the name the contract gives each position. The key is the author's own label; position is not encoded here, because no AD-31 predicate reads argument order."),
+    option: KeyedShapeDescriptor,
+    environment: KeyedShapeDescriptor.describe('AD-18: an environment channel declaration names a variable and its type and never carries a credential value. The same rule the header channel carries, for the channel that plays the same role off an HTTP interface.'),
+    stdin: KeyedShapeDescriptor,
+});
+/**
+ * Which output channel the operation's one response descriptor describes.
+ *
+ * Tagged on `kind` rather than spelled as a bare channel name because `stdout`
+ * is itself a legal `Identifier`: an untagged root could not tell the stream
+ * from an artifact genuinely named `stdout`, which is exactly the ambiguity the
+ * two members below would otherwise share.
+ */
+export const CommandDescriptorChannel = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('stream'),
+        channel: z.enum(['stdout', 'stderr']),
+    }),
+    z.strictObject({
+        kind: z.literal('artifact'),
+        artifactId: Identifier.describe('One of the identifiers this operation declares in `artifacts`. A name absent from that list fails compilation under `unresolved-artifact-reference` rather than resolving absent, because a dangling declaration is an authoring fault the compiler can see.'),
+    }),
+]);
+/**
+ * A command-kind operation. It carries exactly one `ResponseDescriptor`, the
+ * same shape an api operation carries, and `descriptorChannel` says which
+ * output channel that descriptor describes.
+ *
+ * One descriptor rather than one per output channel: AD-19 fixes the descriptor
+ * per operation so that `requiredKeys` has a truthful value, and AD-20 rule 2
+ * reads "the required keys of the response descriptor belonging to the
+ * operation that step invokes" as its denominator. Several descriptors leave
+ * that phrase with several referents, which is the defect AD-19 already records
+ * one level up for an interface-wide union. An operation whose stream and whose
+ * written file both need declared structure is two operations.
+ *
+ * There is no declared success value space for the exit code. AD-19 already
+ * declares one nominated success indicator per operation, and an exit-code
+ * assertion is an ordinary oracle over `/interactions/{stepId}/exit-code`,
+ * which the pointer grammar carries as a scalar channel.
+ */
+export const CommandOperation = z.strictObject({
+    operationId: Identifier,
+    invocation: CommandInvocation,
+    stateChangeMarker: z
+        .boolean()
+        .describe('AD-19: whether the operation is intended to change state. AD-20 rule 7 relevance reads it, and AD-10 selects the sensitivity channel by it. Both values are legal and neither is a default.'),
+    requestShape: CommandRequestShape,
+    artifacts: z
+        .array(Identifier)
+        .describe("The files the operation writes, as bare declared identifiers with existence semantics only. No descriptor and no keys of their own: an artifact pointer's identifier segment resolves against this list, and structure comes from the operation's one response descriptor when `descriptorChannel` nominates that artifact. A pointer naming an identifier absent here fails compilation under `unresolved-artifact-reference`."),
+    descriptorChannel: CommandDescriptorChannel,
+    responseDescriptor: ResponseDescriptor,
+    volatilePointers: z.array(DescriptorPointer),
+    sensitivityWitness: SensitivityWitness.nullable().describe("AD-10, mandatory per declared operation rather than per interface, on the api operation's own terms. `null` is legal only for an operation declaring no keys in any request channel, which for a command means no argument, no option, no environment variable, and no standard input. An input-bearing operation declaring `null` fails a strict compilation under `undeclared-mandatory-input`."),
 });
 /**
  * AD-19's four interface kinds, exported once so nothing else respells them:
@@ -106,10 +192,37 @@ export const Operation = z.strictObject({
  */
 export const INTERFACE_KINDS = ['api', 'web', 'cli', 'mcp'];
 export const InterfaceKind = z.enum(INTERFACE_KINDS);
-export const PermittedInterface = z.strictObject({
-    logicalId: Identifier.describe("AD-35: a logical identifier for the interface, never a URL, host, or port. Mapping it to a target is the caller's, outside the contract."),
-    kind: InterfaceKind.describe('All four kinds are admitted so `unsupported-interface-kind` stays fireable. v0 supports `api`; the other three fail compilation under that code rather than failing to parse.'),
-    operations: z
-        .array(Operation)
-        .describe('No uniqueness constraint: two operations colliding on method plus path template after parameter-name erasure is `duplicate-operation-signature`, a coded compile-time error, and a schema that deduped them would delete it.'),
+const LOGICAL_ID_DESCRIPTION = "AD-35: a logical identifier for the interface, never a URL, host, or port. Mapping it to a target is the caller's, outside the contract.";
+const OPERATIONS_DESCRIPTION = 'No uniqueness constraint: two operations colliding on their transport identity after parameter-name erasure is `duplicate-operation-signature`, a coded compile-time error, and a schema that deduped them would delete it.';
+// `web` and `mcp` carry the api operation shape unchanged. A two-member union
+// would make either one a parse failure, and a parse failure carries no AD-5
+// code, no artifact path, and no name for the kind that is unsupported, which
+// is the opposite of AD-10's "fails compilation honestly under
+// `unsupported-interface-kind`".
+const apiShapedInterface = (kind) => z.strictObject({
+    logicalId: Identifier.describe(LOGICAL_ID_DESCRIPTION),
+    kind: z.literal(kind),
+    operations: z.array(Operation).describe(OPERATIONS_DESCRIPTION),
 });
+/**
+ * Discriminated on `kind`, so an operation shape cannot be smuggled onto the
+ * wrong interface: a `cli` interface declaring `method` and an `api` interface
+ * declaring `invocation` are both parse errors.
+ */
+export const PermittedInterface = z.discriminatedUnion('kind', [
+    apiShapedInterface('api'),
+    apiShapedInterface('web'),
+    apiShapedInterface('mcp'),
+    z.strictObject({
+        logicalId: Identifier.describe(LOGICAL_ID_DESCRIPTION),
+        kind: z.literal('cli'),
+        operations: z.array(CommandOperation).describe(OPERATIONS_DESCRIPTION),
+    }),
+]);
+/**
+ * One interface's operations widened to the element union. TypeScript will not
+ * iterate `iface.operations` directly, because the union's branches give it a
+ * union of array types whose `map` signatures do not unify; this is the one
+ * place that widening is spelled, so no call site invents its own.
+ */
+export const operationsOf = (iface) => iface.operations;

package/dist/core/schemas/isolation-manifest.js

@@ -56,11 +56,17 @@ const accountingShape = Object.fromEntries(FORBIDDEN_INPUT_FLOOR.map((member) =>
  * reasoning behind `RequestShape`'s four-key object.
  */
 export const ForbiddenInputAccountingMap = z.strictObject(accountingShape);
+/**
+ * A label a reader has to be able to act on. Empty is not a mount, a network
+ * target, or a tool call, and an empty entry renders as a basis line with
+ * nothing after its colon.
+ */
+const NonEmptyLabel = z.string().min(1);
 export const IsolationManifest = z
     .strictObject({
     ...lineageFields,
     runId: z.string().min(1),
-    contractId: Identifier.describe('The prior art\'s `taskId`, renamed. "Task" is experiment vocabulary with no product meaning, and the manifest keeps an identifier because it is the artifact `core/ingest` matches against a run; the run record and the probe pin what they describe by digest instead.'),
+    contractId: Identifier.describe('The prior art\'s `taskId`, renamed. "Task" is experiment vocabulary with no product meaning, and the manifest keeps an identifier so a reader can say which contract the run was isolated for. It is a label and not a second operand for any check: `core/ingest` matches this artifact to a run on `runId`, `contractDigest`, and `evaluatorConfigurationDigest`, which is the whole of the agreement the two artifacts make. Nothing in the pipeline carries a contract identifier to compare this against, since the sealed run record pins its contract by digest and the eval contract is not among ingest\'s inputs.'),
     conditionArm: z
         .string()
         .min(1)
@@ -70,21 +76,22 @@ export const IsolationManifest = z
     contractDigest: Digest,
     evaluatorConfigurationDigest: Digest.describe('Added here and absent from the prior art. AD-32 requires this digest to agree between the manifest and the run record, which was previously an agreement rule asserted over two fields that did not exist. Required and non-nullable on both, which is what makes the substitution cost two contradictions rather than one omission. The agreement itself is a cross-artifact rule no schema can see.'),
     workspaceIdentity: z.string().min(1),
-    allowedMounts: z.array(z.string()),
+    allowedMounts: z.array(NonEmptyLabel),
     observedMounts: z
-        .array(z.string())
-        .describe('Observed mounts, network targets, and tool calls exceeding their allowlist is a violation AD-16 has `core/ingest` record; it is a cross-field rule with no AD-5 code and the schema admits it.'),
-    networkAllowlist: z.array(z.string()),
-    observedNetworkTargets: z.array(z.string()),
-    toolAllowlist: z.array(z.string()),
-    observedToolCalls: z.array(z.string()),
+        .array(NonEmptyLabel)
+        .describe('Observed mounts, network targets, and tool calls exceeding their allowlist is a violation AD-16 has `core/ingest` record; it is a cross-field rule with no AD-5 code and the schema admits it. Each entry is non-empty: an empty string is not a mount, and it renders as a basis line naming nothing after its colon.'),
+    networkAllowlist: z.array(NonEmptyLabel),
+    observedNetworkTargets: z.array(NonEmptyLabel),
+    toolAllowlist: z.array(NonEmptyLabel),
+    observedToolCalls: z.array(NonEmptyLabel),
     resourceCeilings: ResourceCeilings,
     actualResourceUse: ActualResourceUse,
     forbiddenInputAccounting: ForbiddenInputAccountingMap.describe('The field AD-16 adds and the prior art lacks: "the isolation manifest\'s required fields … account for each forbidden input by name". Seven keys, generated from `FORBIDDEN_INPUT_FLOOR` so the floor has one home.'),
     violation: z
         .string()
+        .min(1)
         .nullable()
-        .describe("The sixteenth of the prior art's sixteen required members, and the one that is not a description of the run: a non-null violation invalidates it. AD-16 says the schema is \"seeded from the prior art's fifteen\"; the prior art's `required` array has sixteen. Settled by construction: the fifteen are the fields describing the run and this is the invalidation outcome. All sixteen are carried."),
+        .describe("The sixteenth of the prior art's sixteen required members, and the one that is not a description of the run: a non-null violation invalidates it. Non-empty when present, on `QuotedEvidence.quote`'s precedent: `null` is the spelling for no violation, so an empty string is a violation that names nothing while still invalidating the run and rendering a blank basis entry. AD-16 says the schema is \"seeded from the prior art's fifteen\"; the prior art's `required` array has sixteen. Settled by construction: the fifteen are the fields describing the run and this is the invalidation outcome. All sixteen are carried."),
 })
     .meta({
     id: 'IsolationManifest',

package/dist/core/schemas/plan.d.ts

@@ -85,7 +85,7 @@ export declare const BindingChannel: z.ZodNullable<z.ZodRecord<z.ZodString, z.Zo
  * requires every member at parse time and fails five of the Gate C fixture's
  * six steps, all of which bind a subset of the channels.
  */
-export declare const InputBinding: z.ZodObject<{
+export declare const ApiInputBinding: z.ZodObject<{
     path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
         literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
     }, z.core.$strict>, z.ZodObject<{
@@ -135,6 +135,171 @@ export declare const InputBinding: z.ZodObject<{
         principal: z.ZodString;
     }, z.core.$strict>]>>>;
 }, z.core.$strict>;
+/** The same shape over the four channels a command-kind operation accepts. */
+export declare const CommandInputBinding: z.ZodObject<{
+    argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+/**
+ * A plain union rather than a discriminated one, and the agreement between a
+ * step's bound channels and its operation's kind is a compile-time check
+ * rather than a schema refinement.
+ *
+ * A step names an `operationId` and nothing else; the kind of the interface
+ * declaring that operation lives in a different subtree of the same document.
+ * That is the cross-subtree constraint the `{ principal }` comment above
+ * already records as unrepresentable in the export. Adding a `kind` field to
+ * the step itself was the other option and duplicates a fact the operation
+ * already carries, which makes a disagreeing step a second inconsistency to
+ * check rather than one fewer.
+ */
+export declare const InputBinding: z.ZodUnion<readonly [z.ZodObject<{
+    path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    query: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    header: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    body: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>, z.ZodObject<{
+    argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+    stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        matcher: z.ZodEnum<{
+            any: "any";
+            "type-violating": "type-violating";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        captured: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        principal: z.ZodString;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>]>;
+export type InputBinding = z.infer<typeof InputBinding>;
+export type BindingChannel = z.infer<typeof BindingChannel>;
 /**
  * AD-39's declared selector cardinality (owed item 2): what a step means when
  * its selector matches more than one observation was not decided at the
@@ -167,7 +332,7 @@ export declare const SelectorCardinality: z.ZodEnum<{
 export declare const InteractionStep: z.ZodObject<{
     stepId: z.ZodString;
     operationId: z.ZodString;
-    inputBinding: z.ZodObject<{
+    inputBinding: z.ZodUnion<readonly [z.ZodObject<{
         path: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
             literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
         }, z.core.$strict>, z.ZodObject<{
@@ -216,7 +381,56 @@ export declare const InteractionStep: z.ZodObject<{
         }, z.core.$strict>, z.ZodObject<{
             principal: z.ZodString;
         }, z.core.$strict>]>>>;
-    }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        argument: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+        option: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+        environment: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+        stdin: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            literal: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            matcher: z.ZodEnum<{
+                any: "any";
+                "type-violating": "type-violating";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            captured: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            principal: z.ZodString;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>]>;
     after: z.ZodNullable<z.ZodString>;
     cardinality: z.ZodEnum<{
         any: "any";

package/dist/core/schemas/plan.js

@@ -80,12 +80,33 @@ export const BindingChannel = BindingChannelMap.nullable().meta({
  * requires every member at parse time and fails five of the Gate C fixture's
  * six steps, all of which bind a subset of the channels.
  */
-export const InputBinding = z.strictObject({
+export const ApiInputBinding = z.strictObject({
     path: BindingChannel,
     query: BindingChannel,
     header: BindingChannel,
     body: BindingChannel,
 });
+/** The same shape over the four channels a command-kind operation accepts. */
+export const CommandInputBinding = z.strictObject({
+    argument: BindingChannel,
+    option: BindingChannel,
+    environment: BindingChannel,
+    stdin: BindingChannel,
+});
+/**
+ * A plain union rather than a discriminated one, and the agreement between a
+ * step's bound channels and its operation's kind is a compile-time check
+ * rather than a schema refinement.
+ *
+ * A step names an `operationId` and nothing else; the kind of the interface
+ * declaring that operation lives in a different subtree of the same document.
+ * That is the cross-subtree constraint the `{ principal }` comment above
+ * already records as unrepresentable in the export. Adding a `kind` field to
+ * the step itself was the other option and duplicates a fact the operation
+ * already carries, which makes a disagreeing step a second inconsistency to
+ * check rather than one fewer.
+ */
+export const InputBinding = z.union([ApiInputBinding, CommandInputBinding]);
 /**
  * AD-39's declared selector cardinality (owed item 2): what a step means when
  * its selector matches more than one observation was not decided at the

package/dist/core/schemas/pointer.d.ts

@@ -7,9 +7,10 @@ import { z } from 'zod';
  * are exported here because the Sealed Run Record's quoted evidence needs to
  * name a channel by one shared spelling.
  */
-export declare const EVIDENCE_CHANNELS: readonly ['response-body', 'response-headers', 'response-status', 'call-inputs', 'stdout', 'stderr', 'exit-code'];
+export declare const EVIDENCE_CHANNELS: readonly ['response-body', 'response-headers', 'response-status', 'call-inputs', 'stdout', 'stderr', 'exit-code', 'artifact'];
 export type EvidenceChannelName = (typeof EVIDENCE_CHANNELS)[number];
 export declare const EvidenceChannel: z.ZodEnum<{
+    artifact: "artifact";
     "call-inputs": "call-inputs";
     "exit-code": "exit-code";
     "response-body": "response-body";
@@ -31,9 +32,54 @@ export declare const TransportChannel: z.ZodEnum<{
     path: "path";
     query: "query";
 }>;
+/**
+ * The four channels a command-kind operation accepts input on. They sit beside
+ * the transport channels because this module owns channel vocabulary, and the
+ * request shape that declares them has to name them without forward-declaring
+ * a tuple it does not own.
+ *
+ * `stdin` is the command analogue of `body` and inherits its asymmetry: a
+ * request shape declares it as a key map, while one witness leg supplies it as
+ * a tagged body value.
+ */
+export declare const COMMAND_CHANNELS: readonly ['argument', 'option', 'environment', 'stdin'];
+export type CommandChannelName = (typeof COMMAND_CHANNELS)[number];
+/**
+ * Every channel `call-inputs` may take as its next segment, both kinds
+ * together. A pointer is parsed with no contract in hand, so the grammar
+ * admits all eight and the question of which four a given operation may use is
+ * answered by reachability, which has the operation.
+ */
+export declare const INPUT_CHANNELS: readonly ["path", "query", "header", "body", "argument", "option", "environment", "stdin"];
+export type InputChannelName = (typeof INPUT_CHANNELS)[number];
 export declare const TAIL_BEARING_CHANNELS: readonly ["response-body", "response-headers", "stdout", "stderr"];
 export declare const SCALAR_CHANNELS: readonly ["response-status", "exit-code"];
 export declare const TRANSPORT_ROOTED_CHANNEL: "call-inputs";
+export declare const IDENTIFIER_ROOTED_CHANNEL: "artifact";
+/**
+ * The response-side channels each kind produces, and neither produces the
+ * other's. Declared here rather than rebuilt from a description, so a channel
+ * added to the vocabulary has to be assigned to a side and a test can assert
+ * the two partition the response side exactly.
+ *
+ * `call-inputs` belongs to neither: it carries what was sent rather than what
+ * came back, and both kinds have it.
+ */
+export declare const API_RESPONSE_CHANNELS: readonly ["response-body", "response-headers", "response-status"];
+export declare const COMMAND_RESPONSE_CHANNELS: readonly ["stdout", "stderr", "exit-code", "artifact"];
+/**
+ * Every channel but the identifier-rooted one, in the vocabulary's own order.
+ *
+ * Spelled out and typed against the enum rather than filtered from it: a filter
+ * widens to `EvidenceChannelName[]` and `z.enum` needs a tuple, and the whole
+ * point of the list is that adding a ninth channel has to be a decision about
+ * which side of this line it falls on rather than something a filter absorbs.
+ * `tests/schemas/pointer.test.ts` asserts it partitions the vocabulary with
+ * `IDENTIFIER_ROOTED_CHANNEL` exactly.
+ */
+export declare const NON_IDENTIFIER_ROOTED_CHANNELS: readonly ["response-body", "response-headers", "response-status", "call-inputs", "stdout", "stderr", "exit-code"];
+/** Every channel that carries what came back, whichever kind produced it. */
+export declare const RESPONSE_SIDE_CHANNELS: readonly ["response-body", "response-headers", "response-status", "stdout", "stderr", "exit-code", "artifact"];
 export declare const INTERACTION_POINTER_PATTERN: RegExp;
 export declare const BOUND_ELEMENT_POINTER_PATTERN: RegExp;
 export declare const DESCRIPTOR_POINTER_PATTERN: RegExp;