eval-quality 0.1.0 → 0.2.0

package/dist/core/lineage/stage-table.d.ts

@@ -1,9 +1,10 @@
 /**
  * AD-24's stage-signature table and AD-29's producer map, as data: six stages
- * with their inputs, their one owned output, and the lineage edge each writes;
- * twelve interchange artifacts with one producer apiece. The `check:lineage`
- * scanner derives its allowlist from `module`, so the registry import stays
- * type-only to keep zod off that gate's load path.
+ * with their artifact inputs, the non-artifact values they receive, their one
+ * owned output, and the lineage edge each writes; twelve interchange artifacts
+ * with one producer apiece. The `check:lineage` scanner derives its allowlist
+ * from `module`, so the registry import stays type-only to keep zod off that
+ * gate's load path.
  */
 import type { InterchangeArtifactKey } from '../schemas/artifact.ts';
 /** AD-24's six stages, in the order the Consistency Conventions list them. */
@@ -16,6 +17,20 @@ export type PipelineStage = (typeof PIPELINE_STAGES)[number];
  */
 export declare const INTERNAL_PRODUCTS: readonly ['probe-plan', 'probe-observations', 'validated-observations', 'scored-outcomes-and-verdict'];
 export type InternalProduct = (typeof INTERNAL_PRODUCTS)[number];
+/**
+ * Values a stage reads at its boundary that the `inputs` column does not name.
+ * AD-24 writes the table in artifacts, and owed item 6 records the source of
+ * run mode as absent from it: a row naming `sealed-run-record` says which bytes
+ * arrive and leaves open which value fixes the run's mode. Closed rather than
+ * free text, so the column cannot become a notes field.
+ *
+ * The three digests join `mode` for the same reason: they are exactly what
+ * this column exists for, "values a stage reads at its boundary that the
+ * inputs column does not name" -- `emit`'s three caller-attested AD-11
+ * digests have no artifact source anywhere in this pipeline.
+ */
+export declare const STAGE_VALUE_INPUTS: readonly ['mode', 'corpusDigest', 'fixtureDigest', 'evaluatorConfigurationDigest'];
+export type StageValueInput = (typeof STAGE_VALUE_INPUTS)[number];
 /**
  * What a stage does to the two AD-29 fields on the artifact it owns. `mints`
  * covers a root and a revision alike, since both write the fields.
@@ -25,6 +40,8 @@ export type LineageEdge = 'mints' | 'carries-through' | 'none';
 export type ArtifactProducer = PipelineStage | 'caller' | 'embedded';
 export type StageSignature = {
     readonly inputs: readonly (InterchangeArtifactKey | InternalProduct)[];
+    /** non-artifact values the stage receives; see STAGE_VALUE_INPUTS. */
+    readonly valueInputs: readonly StageValueInput[];
     readonly owns: InterchangeArtifactKey | InternalProduct;
     /** the owned output's registry key; null when the output is internal. */
     readonly ownsInterchange: InterchangeArtifactKey | null;

package/dist/core/lineage/stage-table.js

@@ -18,9 +18,28 @@ export const INTERNAL_PRODUCTS = [
     'validated-observations',
     'scored-outcomes-and-verdict',
 ];
+/**
+ * Values a stage reads at its boundary that the `inputs` column does not name.
+ * AD-24 writes the table in artifacts, and owed item 6 records the source of
+ * run mode as absent from it: a row naming `sealed-run-record` says which bytes
+ * arrive and leaves open which value fixes the run's mode. Closed rather than
+ * free text, so the column cannot become a notes field.
+ *
+ * The three digests join `mode` for the same reason: they are exactly what
+ * this column exists for, "values a stage reads at its boundary that the
+ * inputs column does not name" -- `emit`'s three caller-attested AD-11
+ * digests have no artifact source anywhere in this pipeline.
+ */
+export const STAGE_VALUE_INPUTS = [
+    'mode',
+    'corpusDigest',
+    'fixtureDigest',
+    'evaluatorConfigurationDigest',
+];
 export const STAGE_SIGNATURES = {
     compile: {
         inputs: ['eval-contract'],
+        valueInputs: [],
         owns: 'eval-contract',
         ownsInterchange: 'eval-contract',
         // The caller authors the contract and its lineage; `compile` validates
@@ -31,6 +50,7 @@ export const STAGE_SIGNATURES = {
     },
     seal: {
         inputs: ['eval-contract'],
+        valueInputs: [],
         owns: 'sealed-evaluator-brief',
         ownsInterchange: 'sealed-evaluator-brief',
         lineage: 'mints',
@@ -42,15 +62,21 @@ export const STAGE_SIGNATURES = {
             'isolation-manifest',
             'evaluator-configuration',
         ],
+        // Mode arrives on the sealed run record and is named here because owed
+        // item 6 asks the table for the source of run mode. `ingest` is the last
+        // stage that may read it from the caller and the first that may reject
+        // its absence; no later stage derives, recomputes, or defaults it.
+        valueInputs: ['mode'],
         owns: 'validated-observations',
         ownsInterchange: null,
         lineage: 'none',
-        module: null,
+        module: 'src/core/ingest/ingest.ts',
     },
     preflight: {
         // AD-34 splits the stage into `plan` and `reduce`; both halves' inputs
         // are the stage's inputs, and only `reduce` returns an artifact.
         inputs: ['eval-contract', 'probe', 'probe-plan', 'probe-observations'],
+        valueInputs: [],
         owns: 'preflight-verdict',
         ownsInterchange: 'preflight-verdict',
         lineage: 'mints',
@@ -64,19 +90,25 @@ export const STAGE_SIGNATURES = {
             'preflight-verdict',
             'scoring-policy',
         ],
+        valueInputs: [],
         // AD-24: "score produces the outcome and verdict values emit
         // serializes". Owed item 6 records that type as unnamed; this names it.
         owns: 'scored-outcomes-and-verdict',
         ownsInterchange: null,
         lineage: 'none',
-        module: null,
+        module: 'src/core/score/score.ts',
     },
     emit: {
         inputs: ['scored-outcomes-and-verdict'],
+        valueInputs: [
+            'corpusDigest',
+            'fixtureDigest',
+            'evaluatorConfigurationDigest',
+        ],
         owns: 'evidence-artifact',
         ownsInterchange: 'evidence-artifact',
         lineage: 'mints',
-        module: null,
+        module: 'src/core/emit/emit.ts',
     },
 };
 export const ARTIFACT_PRODUCERS = {

package/dist/core/preflight/witness-evidence.js

@@ -39,6 +39,16 @@ export function evidenceOf(projected, observation, inputs) {
     const { body } = projected;
     return {
         observationId: projected.legId,
+        // A synthetic, single-observation shape built fresh per leg and never
+        // collected alongside a sibling: pre-flight resolves one leg's witness
+        // relation at a time, so the schema's ordering and uniqueness concerns
+        // (owed item 2) have nothing to apply to here. Constant, since no reader
+        // of this value cares which leg it was. This stops being safe if
+        // pre-flight ever needs to assemble multiple legs' observations
+        // together: AD-40 already names such a future need, pair-defect signing
+        // across the monotonic sequence of owed item 2, so revisit this
+        // constant then.
+        sequence: 1,
         operationId: projected.operationId,
         provenance: 'baseline',
         callInputs: callInputsOf(inputs),