eval-quality 0.1.0 → 0.2.0

package/dist/core/schemas/scoring-policy.js

@@ -22,6 +22,11 @@ export const ScoringPolicy = z
         .min(0)
         .max(1)
         .describe('The same closed unit interval a finding\'s `confidence` uses. AD-21\'s "a finding whose confidence falls below the policy threshold" compares the two, and two different scales would make that comparison meaningless.'),
+    catchThreshold: z
+        .number()
+        .min(0)
+        .max(1)
+        .describe('AD-7\'s trial-set reducer: a probe counts as caught only when its caught-trial count is strictly greater than this fraction of its valid-trial count, so an exact tie never counts as caught. The published default artifact carries 0.5, the pre-registered "at least two catches in three valid repetitions" read at a valid count of three. No `.default()`, on the same reasoning `confidenceThreshold` gives. Required, not optional, which makes this the scoring policy\'s `schemaVersion` 1 -> 2 BREAKING bump under AD-11, whose rule is that "adding an optional field is a `schemaVersion` bump recorded in the field\'s own description; removing or retyping is breaking". With no default to fill it in, every version-1 policy document fails to parse.'),
     minimumTrialCount: z
         .int()
         .min(1)
@@ -47,5 +52,5 @@ export const ScoringPolicy = z
 })
     .meta({
     id: 'ScoringPolicy',
-    description: 'The scoring policy, with no prior art. It carries the severity floor, confidence threshold, minimum trial count, re-execution cap, remediation cap, and a regex match-step budget that AD-6, AD-12, AD-4, and AD-21 read, and its digest is one of the five named inputs to AD-11\'s scoring version. It is a published artifact rather than a set of constants so that "the default" has an identity a result can name by digest.',
+    description: 'The scoring policy, with no prior art. It carries the severity floor, confidence threshold, catch threshold, minimum trial count, re-execution cap, remediation cap, and a regex match-step budget that AD-6, AD-7, AD-12, AD-4, and AD-21 read, and its digest is one of the six named inputs to AD-11\'s scoring version. It is a published artifact rather than a set of constants so that "the default" has an identity a result can name by digest.',
 });

package/dist/core/schemas/sealed-evaluator-brief.d.ts

@@ -69,6 +69,7 @@ export declare const SealedEvaluatorBrief: z.ZodObject<{
         reference: z.ZodString;
         kind: z.ZodString;
     }, z.core.$strict>>;
+    principals: z.ZodArray<z.ZodString>;
     budgets: z.ZodObject<{
         maxToolCalls: z.ZodInt;
         maxWallClockMinutes: z.ZodInt;

package/dist/core/schemas/sealed-evaluator-brief.js

@@ -45,6 +45,9 @@ export const SealedEvaluatorBrief = z
     scopedResources: z
         .array(ScopedResource)
         .describe("AD-16's scoped resource references. Not nullable here, unlike on the contract: absent-versus-explicitly-empty is an AD-31 grading of a CALLER declaration, and this artifact is generated by `seal`, which always knows the answer. No scoped reference may resolve to a forbidden input; that resolution is `scoped-reference-resolves-forbidden` at compile time and is not a schema check."),
+    principals: z
+        .array(Identifier)
+        .describe("The names declared in the contract's `testData.principals`, sorted. Not nullable, on `scopedResources`'s reasoning above: `seal` always knows the answer, and empty is the legal spelling for a contract declaring none. Names only, no `kind`: `kind` is the author's own opaque vocabulary with no value space any AD declares, so shipping it would put uninterpretable text on the one artifact AD-16 keeps minimal. A name is an opaque label (AD-18), so it discloses no account identifier or credential, and it carries no step identifier (AD-16). Required, not optional, which makes this the sealed brief's `schemaVersion` 1 -> 2 BREAKING bump under AD-11, whose rule is that \"adding an optional field is a `schemaVersion` bump recorded in the field's own description; removing or retyping is breaking\". `[]` is the empty spelling and the key is mandatory, so no version-1 brief parses."),
     budgets: Budgets.describe("The contract's declared ceilings, carried because AD-16 says the caller who executes needs the ceilings the isolation manifest reports against. The manifest's own `resourceCeilings` is a different shape and a different concern: this is a declaration, that is a record of what the harness enforced."),
     safetyLimits: z.array(z.string()),
     probeStepBound: z
@@ -55,5 +58,5 @@ export const SealedEvaluatorBrief = z
 })
     .meta({
     id: 'SealedEvaluatorBrief',
-    description: "The sealed evaluator brief, with no prior art. AD-16 fixes what it carries: the contract's behaviours, the generated evaluator-facing directions of AD-3, permitted interfaces, and scoped resource references, plus budgets and safety limits. It also fixes what the brief never carries: author commentary, the interaction plan, or the plan's step identifiers, and never a prescribed action sequence. Those exclusions are structural rather than conventional: this object is strict, so a brief carrying `interactionPlan`, `commentary`, or a `stepId` fails with `unrecognized_keys`, and each of the three has its own reject fixture rather than resting on strictness alone. It carries no identity field of its own, because every artifact that refers to it does so by digest.",
+    description: "The sealed evaluator brief, with no prior art. AD-16 fixes what it carries: the contract's behaviours, the generated evaluator-facing directions of AD-3, permitted interfaces, scoped resource references, and the declared test-data principal names, plus budgets and safety limits. It also fixes what the brief never carries: author commentary, the interaction plan, or the plan's step identifiers, and never a prescribed action sequence. Those exclusions are structural rather than conventional: this object is strict, so a brief carrying `interactionPlan`, `commentary`, or a `stepId` fails with `unrecognized_keys`, and each of the three has its own reject fixture rather than resting on strictness alone. It carries no identity field of its own, because every artifact that refers to it does so by digest.",
 });

package/dist/core/schemas/sealed-run-record.d.ts

@@ -132,6 +132,7 @@ export declare const OracleDisposition: z.ZodObject<{
     observationIds: z.ZodArray<z.ZodString>;
     note: z.ZodNullable<z.ZodString>;
 }, z.core.$strict>;
+export type OracleDisposition = z.infer<typeof OracleDisposition>;
 /**
  * A flat map would break pointer addressing: AD-26 keys `call-inputs` by
  * transport channel, so a pointer like
@@ -147,16 +148,19 @@ export declare const ObservedCallInputs: z.ZodObject<{
     header: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
     body: z.ZodNullable<z.ZodType<import("./primitives.ts").JsonObject, unknown, z.core.$ZodTypeInternals<import("./primitives.ts").JsonObject, unknown>>>;
 }, z.core.$strict>;
+/** the constraint identifier the ledger carries for the check below. */
+export declare const OBSERVATION_SEQUENCE_UNIQUE = "observation-sequence-unique";
 /**
  * One ingested observation, carrying AD-26's closed channel set so every
  * pointer in the addressing grammar has something to resolve against.
  *
- * Observation ordering is deliberately absent (Owed item 2): ADR-006 forbids
- * using array position as ordering, and the fix, a monotonic sequence, arrives
- * as an additive `schemaVersion` bump under AD-11.
+ * `sequence` closes owed item 2: ADR-006 forbids using array position as
+ * ordering. A required, per-record-unique `sequence` is the total order a
+ * selector reads.
  */
 export declare const Observation: z.ZodObject<{
     observationId: z.ZodString;
+    sequence: z.ZodInt;
     operationId: z.ZodString;
     provenance: z.ZodEnum<{
         baseline: "baseline";
@@ -205,12 +209,34 @@ export declare const EvidenceDisclosure: z.ZodObject<{
     truncationBound: z.ZodNullable<z.ZodInt>;
     reportedIncomplete: z.ZodBoolean;
 }, z.core.$strict>;
+/** exported so the ladder names this shape without importing Zod. */
+export type EvidenceDisclosure = z.infer<typeof EvidenceDisclosure>;
+/**
+ * AD-21's two modes, closed. In `production` the subject is the system under
+ * test; in `contract-scoring` the subject is the contract, the probe is
+ * knowingly defective, and a `caught` outcome is the contract succeeding.
+ *
+ * Declared on the record rather than on the evidence artifact because this is
+ * where mode is now fixed: AD-21 requires mode "fixed before ingest", and an
+ * evidence artifact is `emit`'s output, four stages past the only place a
+ * caller can supply one.
+ */
+export declare const RUN_MODES: readonly ['production', 'contract-scoring'];
+export type RunModeValue = (typeof RUN_MODES)[number];
+export declare const RunMode: z.ZodEnum<{
+    "contract-scoring": "contract-scoring";
+    production: "production";
+}>;
 export declare const SealedRunRecord: z.ZodObject<{
     schemaVersion: z.ZodInt;
     parentDigest: z.ZodNullable<z.ZodString>;
     revisionCount: z.ZodInt;
     runId: z.ZodString;
     conditionArm: z.ZodString;
+    mode: z.ZodEnum<{
+        "contract-scoring": "contract-scoring";
+        production: "production";
+    }>;
     trialIndex: z.ZodInt;
     contractDigest: z.ZodString;
     sealedBriefDigest: z.ZodString;
@@ -320,6 +346,7 @@ export declare const SealedRunRecord: z.ZodObject<{
     }, z.core.$strict>], "findingType">>;
     observations: z.ZodArray<z.ZodObject<{
         observationId: z.ZodString;
+        sequence: z.ZodInt;
         operationId: z.ZodString;
         provenance: z.ZodEnum<{
             baseline: "baseline";

package/dist/core/schemas/sealed-run-record.js

@@ -109,16 +109,22 @@ export const ObservedCallInputs = z.strictObject({
     header: JsonObjectValue.nullable(),
     body: JsonObjectValue.nullable(),
 });
+/** the constraint identifier the ledger carries for the check below. */
+export const OBSERVATION_SEQUENCE_UNIQUE = 'observation-sequence-unique';
 /**
  * One ingested observation, carrying AD-26's closed channel set so every
  * pointer in the addressing grammar has something to resolve against.
  *
- * Observation ordering is deliberately absent (Owed item 2): ADR-006 forbids
- * using array position as ordering, and the fix, a monotonic sequence, arrives
- * as an additive `schemaVersion` bump under AD-11.
+ * `sequence` closes owed item 2: ADR-006 forbids using array position as
+ * ordering. A required, per-record-unique `sequence` is the total order a
+ * selector reads.
  */
 export const Observation = z.strictObject({
     observationId: Identifier,
+    sequence: z
+        .int()
+        .positive()
+        .describe('The total order ADR-006 forbids reading off array position (owed item 2). A positive integer, unique across every observation in the same record: uniqueness is what a sorted-by-`sequence` read needs to be strictly increasing, so no separate monotonicity check is required. Neither starting at 1 nor contiguous is required across a record: only positivity and per-record uniqueness are enforced, so a record whose sequences are e.g. [5, 12, 40] is equally valid. Required rather than optional, which makes this a BREAKING `schemaVersion` bump under AD-11: adding an optional field is additive, and this field is not optional. A record with an absent or duplicated `sequence` fails to parse.'),
     operationId: Identifier.describe('The operation this observation exercised. `Operation.operationId` is scoped to a `PermittedInterface`, so two interfaces may declare the same one; that collision is a cross-artifact rule with no AD-5 code, since `duplicate-operation-signature` covers method plus path template only, and it is left to ingest.'),
     provenance: z
         .enum(['baseline', 'evaluator-chosen'])
@@ -178,6 +184,18 @@ export const EvidenceDisclosure = z.strictObject({
         .boolean()
         .describe('AD-17: "a case that cannot be bounded without discarding disconfirming material is reported incomplete". This is the operand AD-21\'s incomplete condition reads. The remaining two conditions read no field here: unavailable is an `ArtifactReference` that does not resolve through the corpus port, and internally inconsistent is AD-32\'s cross-artifact agreement check. AD-17\'s "must retain evidence contradicting the leading verdict" is decidable by none of them and is recorded as unenforced in v0.'),
 });
+/**
+ * AD-21's two modes, closed. In `production` the subject is the system under
+ * test; in `contract-scoring` the subject is the contract, the probe is
+ * knowingly defective, and a `caught` outcome is the contract succeeding.
+ *
+ * Declared on the record rather than on the evidence artifact because this is
+ * where mode is now fixed: AD-21 requires mode "fixed before ingest", and an
+ * evidence artifact is `emit`'s output, four stages past the only place a
+ * caller can supply one.
+ */
+export const RUN_MODES = ['production', 'contract-scoring'];
+export const RunMode = z.enum(RUN_MODES);
 export const SealedRunRecord = z
     .strictObject({
     ...lineageFields,
@@ -189,6 +207,7 @@ export const SealedRunRecord = z
         .string()
         .min(1)
         .describe("An opaque caller label with no product semantics, per AD-24. The prior art's five-member enum does not survive, and its own extension history is the reason: an enum a local amendment had to widen once for `self-review` will be widened again."),
+    mode: RunMode.describe('AD-21\'s run mode, supplied by the caller on the record and never derived, recomputed, or defaulted afterwards. AD-21 requires mode to be "fixed before ingest", and owed item 4 records what its absence costs: the same sealed run could be relabelled after ingest and scored under the same scoring version. Required rather than optional, which makes this a BREAKING `schemaVersion` bump under AD-11, whose rule is that "adding an optional field is a `schemaVersion` bump recorded in the field\'s own description; removing or retyping is breaking". A version-1 record carries no mode, and no default may repair one into a version-2 record, because a defaulted mode is the relabelling this field exists to stop. A record presenting no mode fails to parse, which AD-28 makes a `schema-parse-failure` fault rather than an AD-21 verdict or an AD-5 code, the same routing `evaluatorRecommendation` already records for an unrecognised value. This field is where mode is read from; the evidence artifact restates it and is never the source.'),
     trialIndex: z
         .int()
         .min(1)
@@ -199,7 +218,20 @@ export const SealedRunRecord = z
     evaluatorRecommendation: EvaluatorRecommendation,
     oracleDispositions: z.array(OracleDisposition),
     findings: z.array(Finding),
-    observations: z.array(Observation),
+    observations: z
+        .array(Observation)
+        .refine((observations) => {
+        const seen = new Set();
+        for (const observation of observations) {
+            if (seen.has(observation.sequence))
+                return false;
+            seen.add(observation.sequence);
+        }
+        return true;
+    }, {
+        error: "every observation's `sequence` is unique within the record (ADR-006, owed item 2); a duplicate leaves the total order the fix exists to supply ambiguous",
+    })
+        .describe('Per-observation `sequence` uniqueness is enforced here. The published JSON Schema dialect has no keyword for uniqueness of a nested field across array items, so this constraint is Zod-only: a non-Zod consumer must reimplement it, exactly as with any other cross-item invariant this dialect cannot state.'),
     judgeResults: z
         .array(JudgeResult)
         .describe('Empty is legal: a contract with no rubric produces no judge call.'),
@@ -211,5 +243,5 @@ export const SealedRunRecord = z
 })
     .meta({
     id: 'SealedRunRecord',
-    description: "One sealed evaluator trial, as the caller presents it. Succeeds the prior-art `h0-run-result` schema per AD-24, keeping its run identifier, condition arm, findings, action-log reference, resource use, invalidation reason, evaluator recommendation as a closed enum, and per-finding confidence on a declared scale. Divergences: `condition` is demoted to the opaque `conditionArm`, `verdict` becomes `evaluatorRecommendation` without `NOT_APPLICABLE`, money is a decimal string, and `taskId`, `note`, and per-finding `actionIds` do not survive: the contract is pinned by `contractDigest`, an unstructured orchestrator annotation is the free-prose channel the Conventions close everywhere else, and two citation vocabularies on one finding is the ambiguity ADR-009 removed. Two constructions are deliberately absent and each is owed to an open item: the run MODE, which AD-21 requires to be fixed before ingest and to enter AD-11's identity inputs rather than appearing first in the evidence artifact (Owed item 4), and observation ORDERING, which ADR-006 forbids reading off array position (Owed item 2). Both arrive as additive `schemaVersion` bumps under AD-11.",
+    description: "One sealed evaluator trial, as the caller presents it. Succeeds the prior-art `h0-run-result` schema per AD-24, keeping its run identifier, condition arm, findings, action-log reference, resource use, invalidation reason, evaluator recommendation as a closed enum, and per-finding confidence on a declared scale. Divergences: `condition` is demoted to the opaque `conditionArm`, `verdict` becomes `evaluatorRecommendation` without `NOT_APPLICABLE`, money is a decimal string, and `taskId`, `note`, and per-finding `actionIds` do not survive: the contract is pinned by `contractDigest`, an unstructured orchestrator annotation is the free-prose channel the Conventions close everywhere else, and two citation vocabularies on one finding is the ambiguity ADR-009 removed. The run MODE landed here as a required field under a BREAKING `schemaVersion` bump, which is where AD-21's \"fixed before ingest\" puts it; owed item 4 is now closed: mode enters AD-11's identity inputs as `ScoringVersionInputs`'s sixth field, and `core/score/ladder.ts` carries `ProductionAssessment`/`ContractAssessment` as the two assessment input types with their own total ladders. Observation ORDERING landed here too, under its own BREAKING `schemaVersion` bump: `sequence` is required and unique per record, closing owed item 2's ADR-006 gap, since array position was never a legal ordering.",
 });

package/dist/core/score/binding-order.d.ts

@@ -0,0 +1,31 @@
+import type { InteractionStep } from '../schemas/plan.ts';
+export type BindingOrder = {
+    /** Ascending tiers; within each, steps in declaration order. Every declared id appears exactly once. */
+    readonly tiers: readonly (readonly string[])[];
+    /**
+     * Ids Kahn's algorithm left unplaced, in declaration order: the members of an
+     * ordering cycle and every step downstream of one, since a step whose
+     * dependency never gets a tier never gets one either.
+     */
+    readonly cyclic: readonly string[];
+};
+/**
+ * Cyclic steps come back as data instead of an exception, matching
+ * `selectObservations`'s own policy of reporting ambiguity rather than deciding
+ * it. A compiled contract whose step ids are unique never reaches that list:
+ * `binding-cycle` rejects every cycle carrying a capture edge and
+ * `nested-temporal-clause` every cycle made of `after` edges alone, so the
+ * union graph is acyclic by the time any record is scored.
+ *
+ * The uniqueness clause is load-bearing. `checkNestedTemporalClause` resolves
+ * `after` through a plan index built with `duplicateIds: 'unresolved'`, which
+ * deletes a duplicated id and reads any clause naming it as dangling, while
+ * this function and `checkBindingCycle` both test against the raw declared-id
+ * set, where it is present. So a plan declaring one id twice can carry an
+ * `after` cycle those two disagree about, and its steps land here. Nothing
+ * downstream sees it: `seal` builds its own index with the default throwing
+ * option and rejects a duplicate id outright. Changing how
+ * `checkNestedTemporalClause` reads a duplicate is deliberate shipped
+ * behaviour and belongs to whoever owns that check.
+ */
+export declare function bindingOrder(interactionPlan: readonly InteractionStep[]): BindingOrder;

package/dist/core/score/binding-order.js

@@ -0,0 +1,88 @@
+/**
+ * The order a plan's steps must be resolved in when one step's selection
+ * depends on another's. Kahn tiers over the union of the capture edges and
+ * AD-39's `after` edges, the same graph `checkBindingCycle` builds: every step
+ * in tier n depends only on steps in tiers below n, so a caller walking the
+ * tiers in order always has what it needs resolved by the time it reads it.
+ *
+ * The `after` edge is in the graph because `selectWithBindings` resolves a
+ * temporal anchor through the same binding filter as everything else, so a step
+ * can read an anchor whose own capture sites must already be written. Tiering
+ * captures alone made the answer depend on declaration order within a tier: two
+ * same-tier steps swapped flipped a verdict between `none` and one match.
+ *
+ * `{ literal }`, `{ matcher }`, and `{ principal }` bindings declare no
+ * dependency, so a step carrying only those and no clause is tier zero. So is a
+ * step whose captured pointer or `after` clause names an id the plan does not
+ * declare: a dangling capture is `unreachable-check-evidence`'s at compile time,
+ * AD-39 makes a dangling `after` permissive, and nothing here should invent an
+ * ordering for either.
+ *
+ * Within a tier the order is the order the steps are declared in
+ * `interactionPlan`, which is what "sequence order within a tier" can mean at
+ * compile time, where no observation `sequence` exists yet. ADR-006 bans
+ * reading order off array position in a run record, where the array is an
+ * ingest artifact nobody authored; a contract's `interactionPlan` is the
+ * author's own declaration, and permuting it yields a different contract with a
+ * different digest, so there is no permutation invariance to preserve.
+ */
+import { capturedBindings } from '../compile/bindings.js';
+/**
+ * Cyclic steps come back as data instead of an exception, matching
+ * `selectObservations`'s own policy of reporting ambiguity rather than deciding
+ * it. A compiled contract whose step ids are unique never reaches that list:
+ * `binding-cycle` rejects every cycle carrying a capture edge and
+ * `nested-temporal-clause` every cycle made of `after` edges alone, so the
+ * union graph is acyclic by the time any record is scored.
+ *
+ * The uniqueness clause is load-bearing. `checkNestedTemporalClause` resolves
+ * `after` through a plan index built with `duplicateIds: 'unresolved'`, which
+ * deletes a duplicated id and reads any clause naming it as dangling, while
+ * this function and `checkBindingCycle` both test against the raw declared-id
+ * set, where it is present. So a plan declaring one id twice can carry an
+ * `after` cycle those two disagree about, and its steps land here. Nothing
+ * downstream sees it: `seal` builds its own index with the default throwing
+ * option and rejects a duplicate id outright. Changing how
+ * `checkNestedTemporalClause` reads a duplicate is deliberate shipped
+ * behaviour and belongs to whoever owns that check.
+ */
+export function bindingOrder(interactionPlan) {
+    // A duplicated id collapses to one node: the plan declares one name, and
+    // which of two same-named steps a capture meant is undecidable here.
+    const declared = [];
+    const dependencies = new Map();
+    for (const step of interactionPlan) {
+        if (dependencies.has(step.stepId))
+            continue;
+        declared.push(step.stepId);
+        dependencies.set(step.stepId, new Set());
+    }
+    for (const step of interactionPlan) {
+        const own = dependencies.get(step.stepId);
+        if (own === undefined)
+            continue;
+        for (const capture of capturedBindings(step)) {
+            const { stepId } = capture.target;
+            // A self-reference is a cycle of one, so it stays in the graph and lands
+            // in `cyclic` rather than being filtered into tier zero.
+            if (dependencies.has(stepId))
+                own.add(stepId);
+        }
+        if (step.after !== null && dependencies.has(step.after)) {
+            own.add(step.after);
+        }
+    }
+    const tiers = [];
+    const placed = new Set();
+    while (placed.size < declared.length) {
+        const tier = declared.filter((stepId) => !placed.has(stepId) &&
+            [...(dependencies.get(stepId) ?? [])].every((id) => placed.has(id)));
+        // Every remaining step depends on another remaining step, which is a cycle.
+        if (tier.length === 0)
+            break;
+        tiers.push(tier);
+        for (const stepId of tier)
+            placed.add(stepId);
+    }
+    return { tiers, cyclic: declared.filter((stepId) => !placed.has(stepId)) };
+}

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

@@ -0,0 +1,93 @@
+import { type ResolvedValue } from '../evaluate/resolved-value.ts';
+import type { InteractionStep } from '../schemas/plan.ts';
+import { type TransportChannelName } from '../schemas/pointer.ts';
+import type { JsonValue } from '../schemas/primitives.ts';
+import type { Observation } from '../schemas/sealed-run-record.ts';
+import { type PlanIndex } from '../seal/plan-index.ts';
+import { type StepSelection } from './selection.ts';
+/**
+ * One captured pointer's resolution. `ResolvedValue` alone cannot carry this:
+ * it is `JsonValue | ABSENT` with nowhere to put the observation the value came
+ * from, its `sequence`, or the referenced step's named ambiguity. `sequence` is
+ * what gives "earlier" a runtime meaning, since a capture graph that is acyclic
+ * still says nothing about which observation came first.
+ */
+export type CapturedResolution = {
+    readonly status: 'resolved';
+    readonly value: ResolvedValue;
+    readonly observationId: Observation['observationId'];
+    readonly sequence: number;
+} | {
+    readonly status: 'absent';
+} | {
+    readonly status: 'ambiguous';
+    readonly matchedObservationIds: readonly Observation['observationId'][];
+};
+/**
+ * The key one captured binding occupies in the resolution map. Keyed by
+ * binding site rather than by pointer: one step can carry several captured
+ * bindings, and two of them may name the same pointer in different channels.
+ * 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: TransportChannelName, key: string): string;
+/**
+ * Resolves one captured pointer against the record.
+ *
+ * The referenced step is selected through `selectWithBindings`, so its own
+ * selection predicate applies before a value is read off it. Selecting it with
+ * `selectObservations` alone would match on `operationId` and leave a step that
+ * only its own bindings separate reporting the named ambiguity, which would
+ * make a capture from either half of a literal-bound collision pair resolve
+ * nothing at all. `resolved` carries the referenced step's own captured values,
+ * already filled by the tier below it, which is what makes the tiering
+ * load-bearing.
+ *
+ * The three dispositions already settled hold unchanged over the filtered
+ * result: one match binds, several under a declared `any` binds the lowest
+ * `sequence`, and several under `exactly-one`/`at-most-one` is the named
+ * ambiguity, returned as data with no value resolved.
+ *
+ * A pointer whose step the plan does not declare, or whose referenced step
+ * matched nothing, resolves `absent`.
+ *
+ * `resolved` as a status means an observation was selected, which is a
+ * different fact from the pointer finding a value in it: a tail that walks off
+ * the observed body comes back `resolved` carrying `ABSENT`, with the source
+ * observation and its `sequence` intact. That is why `CapturedResolution.value`
+ * is `ResolvedValue`. AD-26 makes absent an observation rather than an error,
+ * and `deepEquals` is false against it, so the referencing step still selects
+ * `none`; keeping the source observation means the ordering floor stays
+ * computable either way.
+ */
+export declare function resolveCapturedValue(pointer: string, index: PlanIndex, observations: readonly Observation[], resolved: ReadonlyMap<string, CapturedResolution>): CapturedResolution;
+/**
+ * Every captured binding in the plan, resolved in `bindingOrder`'s tiers and
+ * keyed by binding site. Walking the tiers in order is what lets a step's
+ * captured values be resolved against a referenced step whose own captures are
+ * already in the map. Steps `bindingOrder` reports cyclic are left out, so
+ * their bindings resolve as unlisted and filter every candidate away.
+ */
+export declare function resolveCapturedBindings(interactionPlan: readonly InteractionStep[], index: PlanIndex, observations: readonly Observation[]): ReadonlyMap<string, CapturedResolution>;
+export declare function deepEquals(a: ResolvedValue, b: ResolvedValue): boolean;
+export declare function jsonTypeOf(value: JsonValue): string;
+/**
+ * `selectObservations`, then the step's own selection predicate as a filter
+ * over the matches, then the cardinality verdict over what survived.
+ *
+ * The order is temporal clause, then capture ordering, then the binding
+ * filters. Ordering is enforced at score time as well as at compile time: the
+ * persistence read-back this exists for is exactly a claim about order, and a
+ * record whose `GET` sits at `sequence` 2 and whose `POST` sits at `sequence` 9
+ * would otherwise satisfy the binding and pass an oracle proving the opposite.
+ *
+ * `resolved` is the map `resolveCapturedBindings` fills from `bindingOrder`'s
+ * tiers, keyed by binding site. An unlisted or unresolved site filters every
+ * candidate out, so a caller that skipped a tier gets `none` rather than a
+ * silently wrong match.
+ *
+ * A filter over zero bindings and no clause separates nothing, so two steps
+ * sharing an operation and declaring neither both still return `several`: the
+ * declared structure does not distinguish them.
+ */
+export declare function selectWithBindings(step: InteractionStep, observations: readonly Observation[], index: PlanIndex, resolved: ReadonlyMap<string, CapturedResolution>): StepSelection;