@mutagent/evaluator 0.1.0-alpha.6 → 0.2.0-alpha.1

package/.claude/skills/mutagent-evaluator/scripts/materialize-dataset.ts

@@ -1,24 +1,27 @@
 /**
- * scripts/materialize-dataset.ts — F8: MATERIALIZE real dataset items from the
- * agentspec (Type A — PURE). Seed → ACTUAL items, not just definitions.
+ * scripts/materialize-dataset.ts — F8: PROJECT the agentspec's real dataset items
+ * into runnable evaluator DatasetCases (Type A — PURE).
  * ---------------------------------------------------------------------------
- * The ADL `*build` stage emits an agentspec whose `definition.evals` carries the
- * dataset DEFINITION (dataset_categories[] × edge_cases[]) + scenarios[]. The old
- * `*build-dataset` only had the dimensions/definitions; F8 requires it to
- * MATERIALIZE real, runnable DatasetCases — ≥1 per category, plus one per declared
- * edge_case — BEFORE the dataset-builder agent expands them synthetically.
+ * AgentSpec 0.3.0 (D18/D19) moved the dataset from a DEFINITION (0.2's
+ * `dataset_categories[] × edge_cases[]`, which the evaluator had to synthesize
+ * base+edge queries from) to `spec.evaluation.datasets[].items[]` — REAL,
+ * already-materialized rows, each carrying `category` / `scenarioRef` / a `case`
+ * assignment over the dataset's `caseDimensions`, plus kind-specific `input` /
+ * `expected` payloads.
  *
- * The materialized cases are the SEED layer (source: "seed"):
- *   - one BASE item per category — from a category-tagged scenario when present,
- *     else synthesized from the category description ("seed, don't duplicate").
- *   - one EDGE item per declared edge_case — query = the edge_case phrase in the
- *     category's context; flagged `edge_case: "true"` in its tuple.
+ * So materialization is now a faithful PROJECTION, not a synthesis:
+ *   - one DatasetCase per spec item (the seed layer, source: "seed").
+ *   - the case TUPLE = the item's `category` + its `case` assignment (the axes the
+ *     dataset varies over — see `dimensionsFromAgentspec`).
+ *   - the case QUERY = the item's opaque `input` payload rendered deterministically
+ *     (raw string when `input` is a string; a stable key-sorted serialization
+ *     otherwise), so a re-projection is byte-identical.
  *
- * These are REAL queries (non-empty NL), not category definitions. The
- * dataset-builder agent then expands them; build-dataset.ts's deterministic
- * id/dedup/merge dedups any overlap. Subject-agnostic. DETERMINISTIC — stable
- * content-derived ids, scenarios/categories/edge_cases consumed in given order;
- * no clock / random / network → re-materializing is byte-identical (C-PIN).
+ * The dataset-builder agent then EXPANDS these seeds synthetically; build-dataset.ts's
+ * deterministic id/dedup/merge dedups any overlap. Subject-agnostic (EV-002): axes
+ * and values come from the agentspec, never hard-coded. DETERMINISTIC — items and
+ * axes consumed in given order; no clock / random / network → re-projecting is
+ * byte-identical (C-PIN).
  */
 import {
   type Dataset,
@@ -26,88 +29,147 @@ import {
   type DatasetTuple,
   type Dimension,
 } from "./contracts/dataset.ts";
-import type { AgentspecEvals, AgentspecScenario } from "./contracts/agentspec-evals.ts";
+import type {
+  SpecEvaluation,
+  SpecEvalDatasetItem,
+} from "./contracts/agentspec-evals.ts";
 import { buildCase, appendToDataset } from "./build-dataset.ts";
 import { CaseSource } from "./contracts/dataset.ts";
 
-/** The literal tuple values for the boolean edge_case dimension (DatasetTuple is string-valued). */
-const EDGE_TRUE = "true";
-const EDGE_FALSE = "false";
+/** The tuple key under which an item's dataset-local category is recorded. */
+const CATEGORY_DIM = "category";
 
 /**
- * The dimensions the materialized dataset varies over: `category` (values = the
- * category ids) + `edge_case` (boolean). Subject-agnostic — derived from the
- * agentspec, never hard-coded. PURE.
+ * Deterministic, key-sorted serialization — a stable rendering of an opaque item
+ * payload so two projections of the same payload are byte-identical regardless of
+ * key insertion order. PURE.
  */
-export function dimensionsFromAgentspec(evals: AgentspecEvals): Dimension[] {
-  const categories = evals.dataset_categories.map((c) => c.id);
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const record = value as Record<string, unknown>;
+  const body = Object.keys(record)
+    .sort()
+    .map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`)
+    .join(",");
+  return `{${body}}`;
+}
+
+/**
+ * The dimensions the projected dataset varies over: `category` (values = the
+ * dataset-local category ids, first-seen order) + one dimension per distinct
+ * `caseDimensions` axis (values merged across datasets, first-seen order). Both are
+ * derived from the agentspec, never hard-coded. Subject-agnostic. PURE.
+ */
+export function dimensionsFromAgentspec(evaluation: SpecEvaluation): Dimension[] {
   const dims: Dimension[] = [];
-  if (categories.length > 0) {
-    dims.push({ name: "category", description: "the dataset-category slice", values: categories });
+
+  // category dimension — the union of dataset-local category ids (first-seen, deduped).
+  const categoryIds: string[] = [];
+  const seenCategory = new Set<string>();
+  for (const dataset of evaluation.datasets) {
+    for (const category of dataset.categories ?? []) {
+      if (seenCategory.has(category.id)) continue;
+      seenCategory.add(category.id);
+      categoryIds.push(category.id);
+    }
+  }
+  if (categoryIds.length > 0) {
+    dims.push({ name: CATEGORY_DIM, description: "the dataset-local category slice", values: categoryIds });
   }
-  dims.push({ name: "edge_case", description: "is this an edge/adversarial case", values: [EDGE_FALSE, EDGE_TRUE] });
-  return dims;
-}
 
-/** The first scenario tagged into `categoryId` (given order), if any. PURE. */
-function baseScenarioFor(evals: AgentspecEvals, categoryId: string): AgentspecScenario | undefined {
-  return evals.scenarios.find((s) => s.category === categoryId && s.edge_case !== true);
+  // caseDimensions — each named axis, values merged across datasets (first-seen, deduped).
+  const axisOrder: string[] = [];
+  const axes = new Map<string, { description?: string; values: string[]; seen: Set<string> }>();
+  for (const dataset of evaluation.datasets) {
+    for (const [name, axis] of Object.entries(dataset.caseDimensions ?? {})) {
+      let entry = axes.get(name);
+      if (entry === undefined) {
+        entry = { values: [], seen: new Set<string>() };
+        if (axis.description !== undefined) entry.description = axis.description;
+        axes.set(name, entry);
+        axisOrder.push(name);
+      }
+      for (const value of axis.values) {
+        if (entry.seen.has(value)) continue;
+        entry.seen.add(value);
+        entry.values.push(value);
+      }
+    }
+  }
+  for (const name of axisOrder) {
+    const entry = axes.get(name);
+    if (entry === undefined) continue;
+    const dim: Dimension = { name, values: entry.values };
+    if (entry.description !== undefined) dim.description = entry.description;
+    dims.push(dim);
+  }
+
+  return dims;
 }
 
-/** The base query for a category — the scenario text when tagged, else the description. PURE. */
-function baseQueryFor(evals: AgentspecEvals, categoryId: string, description: string): string {
-  const scenario = baseScenarioFor(evals, categoryId);
-  return scenario !== undefined ? scenario.description : description;
+/**
+ * The variation tuple an item realizes — its dataset-local `category` (when present)
+ * plus its `case` axis assignments. Falls back to the item id when an item declares
+ * neither (a DatasetTuple must have ≥1 assignment). PURE.
+ */
+function tupleFromItem(item: SpecEvalDatasetItem): DatasetTuple {
+  const tuple: DatasetTuple = {};
+  if (item.category !== undefined && item.category.length > 0) tuple[CATEGORY_DIM] = item.category;
+  for (const [axis, value] of Object.entries(item.case ?? {})) tuple[axis] = value;
+  if (Object.keys(tuple).length === 0) tuple.item = item.id;
+  return tuple;
 }
 
-/** The edge query for an edge_case phrase in a category context. PURE. */
-function edgeQueryFor(categoryId: string, edgePhrase: string): string {
-  // A real NL query expressing the edge condition in the category's context.
-  return `[${categoryId}] handle the edge case: ${edgePhrase}`;
+/**
+ * The natural-language query an item realizes — its opaque `input` payload rendered
+ * deterministically. A string input is used verbatim; any other payload is
+ * stable-serialized; a missing payload falls back to a deterministic descriptor so
+ * the query is always non-empty (DatasetCase requires it). PURE.
+ */
+function queryFromItem(item: SpecEvalDatasetItem): string {
+  const input = item.input;
+  if (typeof input === "string" && input.length > 0) return input;
+  if (input !== undefined) {
+    const rendered = stableStringify(input);
+    if (rendered.length > 0) return rendered;
+  }
+  const context = item.category ?? item.scenarioRef ?? item.id;
+  return `[${context}] ${item.id}`;
 }
 
 /**
- * MATERIALIZE real DatasetCases from the agentspec.evals seed (F8). For EACH
- * category: one base item (≥1 per category — the success gate) + one item per
- * declared edge_case (flagged edge_case). DETERMINISTIC, deduped by content id.
- * Returns [] for an empty evals block (no categories → no items). PURE.
+ * PROJECT the agentspec's real dataset items (0.3.0 `spec.evaluation.datasets[].items[]`)
+ * into runnable DatasetCases (F8), one seed case per item. DETERMINISTIC, deduped by
+ * content id (a re-projection collides → drop). Returns [] when no dataset carries
+ * items. PURE.
  */
-export function materializeFromAgentspec(evals: AgentspecEvals): DatasetCase[] {
+export function materializeFromAgentspec(evaluation: SpecEvaluation): DatasetCase[] {
   const out: DatasetCase[] = [];
   const seen = new Set<string>();
-  const push = (tuple: DatasetTuple, query: string): void => {
-    const c = buildCase(tuple, query, CaseSource.Seed);
-    if (seen.has(c.id)) return; // content-id dedup (re-materialize collides → drop)
-    seen.add(c.id);
-    out.push(c);
-  };
-  for (const cat of evals.dataset_categories) {
-    // base item — one real query per category.
-    push(
-      { category: cat.id, edge_case: EDGE_FALSE },
-      baseQueryFor(evals, cat.id, cat.description),
-    );
-    // edge items — one real query per declared edge_case.
-    for (const edge of cat.edge_cases) {
-      if (edge.length === 0) continue;
-      push({ category: cat.id, edge_case: EDGE_TRUE }, edgeQueryFor(cat.id, edge));
+  for (const dataset of evaluation.datasets) {
+    for (const item of dataset.items ?? []) {
+      const c = buildCase(tupleFromItem(item), queryFromItem(item), CaseSource.Seed);
+      if (seen.has(c.id)) continue; // content-id dedup (re-project collides → drop)
+      seen.add(c.id);
+      out.push(c);
     }
   }
   return out;
 }
 
 /**
- * Assemble (or extend) a Dataset seeded with the materialized real items. When
- * `existing` is supplied, the materialized cases are merged MONOTONICALLY (no
+ * Assemble (or extend) a Dataset seeded with the projected real items. When
+ * `existing` is supplied, the projected cases are merged MONOTONICALLY (no
  * duplicates, version bumps). Subject-agnostic. DETERMINISTIC. PURE.
  */
 export function materializeToDataset(
   subject: string,
-  evals: AgentspecEvals,
+  evaluation: SpecEvaluation,
   existing?: Dataset,
 ): Dataset {
-  const dimensions = dimensionsFromAgentspec(evals);
-  const cases = materializeFromAgentspec(evals);
+  const dimensions = dimensionsFromAgentspec(evaluation);
+  const cases = materializeFromAgentspec(evaluation);
   const base: Dataset = existing ?? { subject, dimensions, cases: [], version: 0 };
   return appendToDataset(base, cases);
 }

package/.claude/skills/mutagent-evaluator/scripts/matrix-judge.ts

@@ -85,6 +85,18 @@ function transcriptOf(trace: EvalTrace): TranscriptTurn[] {
   return turns;
 }
 
+/**
+ * The VERIFY-SURFACE view of a situation: each trace augmented with the SAME
+ * deterministic `trajectory`/`transcript` projections its packet was built from
+ * (`trajectoryOf`/`transcriptOf`). A judge cites refs against the packet it was
+ * handed — those paths must re-resolve at verify time, or a syntax/shape gap
+ * (not evidence weakness) silently downgrades a grounded verdict. Trace-shaped
+ * paths (`observations.N.…`) keep resolving via the spread. PURE.
+ */
+export function verifySituationViews(traces: EvalTrace[]): EvalTrace[] {
+  return traces.map((t) => ({ ...t, trajectory: trajectoryOf(t), transcript: transcriptOf(t) }) as EvalTrace);
+}
+
 // ── T1 (B-U3) tier-0 deterministic pre-pass ──────────────────────────────────
 //
 // THE real cost lever (§9.4.1): run the code-method rows FIRST (deterministic,
@@ -338,6 +350,7 @@ export function buildMatrixPacket(
   criteria: MatrixCriterion[],
   pin: { model: string; temperature: 0 },
   subjectProfile?: SubjectProfile,
+  layerScope?: string[],
 ): MatrixPacket {
   const packet: MatrixPacket = {
     subject,
@@ -349,6 +362,9 @@ export function buildMatrixPacket(
     // byte-stable legacy packet (the judge reconstructs the profile at reason-time).
     ...(subjectProfile !== undefined ? { subjectProfile } : {}),
     pin,
+    // v3 D1=B+ — the pipeable `*evaluate-<layer>` filter. ABSENT/empty ⇒ the FULL
+    // walk (byte-stable legacy packet — the field is omitted entirely).
+    ...(layerScope !== undefined && layerScope.length > 0 ? { layerScope } : {}),
   };
   assertMatrixPacket(packet);
   return packet;
@@ -604,7 +620,14 @@ export function aggregateMatrixScorecard(input: MatrixAggregateInput): MatrixAgg
   // proof that a DIFFERENT judge ran, not just "eligible for".
   const independentVerify: IndependentVerifyRecord[] = [];
   if (input.independentVerify !== undefined) {
-    const { situation, signals } = input.independentVerify;
+    const { situation: rawSituation, signals } = input.independentVerify;
+    // The judge cites refs against the PACKET it was handed (trajectory[]/transcript[]
+    // projections), but the raw EvalTrace carries neither field — so a deterministic
+    // re-resolve against bare traces reads every packet-shaped ref as DEAD and
+    // silently downgrades a grounded fail to uncertain (observed live: gate flipped
+    // fail → incomplete on a verifier-UPHELD defect). Re-resolve against the trace
+    // AUGMENTED with the same deterministic projections the packet was built from.
+    const situation = verifySituationViews(rawSituation);
     const gatingFails = gatingFailVerdicts(verdicts, severityById, input.gatingSeverities);
     const gatingFailIds = new Set(gatingFails.map((v) => v.criterionId));
     for (const v of verdicts) {
@@ -748,3 +771,198 @@ export function readMatrixVerdictFiles(verdictDir: string, trajectoryIds: string
   }
   return raws;
 }
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// v3 LAYERED WALK — aggregate-side folds (E-NEW-1/3/9 · D2-A). ALL PURE, ALL
+// ADDITIVE: consumed by run-evaluate AFTER the (untouched) criteria aggregate;
+// the GATE function is NOT edited — layer verdicts are diagnostic columns and
+// cross-layer CONFLICTS are surfaced for a human, never auto-resolved (OT-1).
+// ═══════════════════════════════════════════════════════════════════════════════
+
+import { LAYER_IDS, type LayerVerdict, type WalkEmissions } from "./contracts/eval-matrix.ts";
+
+/** One trajectory's layer row for the report's layer matrix (skipped ≠ undecidable). */
+export interface LayerFoldRow {
+  trajectoryId: string;
+  /** layer id → verdict; layers the walk never mentioned are `absent` (pre-v3 file →
+   *  NAMED degrade); `fired` = the L0 evidence-state (patterns fired, no verdict). */
+  byLayer: Record<string, "pass" | "fail" | "undecidable" | "skipped" | "fired" | "no-fires" | "absent">;
+  earlyExit?: string;
+  /** COERCED to a count (a live judge may emit the engaged layer-id LIST). */
+  layersEngaged?: number;
+}
+
+/** Per-layer fold buckets. `other` is the NaN-proof catch-all for any tolerant
+ *  verdict value the buckets don't know yet — surfaced, never silently dropped
+ *  (the raw value stays visible in the row's `byLayer`). */
+export interface LayerFoldTotals {
+  pass: number;
+  fail: number;
+  undecidable: number;
+  skipped: number;
+  fired: number;
+  /** L0 clean-state (library ran, no pattern fired) — honest clean, never a pass. */
+  "no-fires": number;
+  absent: number;
+  other: number;
+}
+
+/** Coerce a tolerant `layersEngaged` (count OR layer-id list) to a count. */
+export function layersEngagedCount(v: number | string[] | undefined): number | undefined {
+  return Array.isArray(v) ? v.length : v;
+}
+
+/** E-NEW-1 — fold per-walk layerVerdicts into per-trajectory rows + per-layer totals. */
+export function foldLayerVerdicts(files: MatrixVerdictFile[]): {
+  rows: LayerFoldRow[];
+  totals: Record<string, LayerFoldTotals>;
+} {
+  const totals: Record<string, LayerFoldTotals> = {};
+  for (const layer of LAYER_IDS)
+    totals[layer] = { pass: 0, fail: 0, undecidable: 0, skipped: 0, fired: 0, "no-fires": 0, absent: 0, other: 0 };
+  const rows: LayerFoldRow[] = files.map((file) => {
+    const byLayer: LayerFoldRow["byLayer"] = {};
+    for (const layer of LAYER_IDS) {
+      const lv = (file.layerVerdicts ?? []).find((x: LayerVerdict) => x.layer === layer);
+      const v = (lv?.verdict ?? "absent") as LayerFoldRow["byLayer"][string];
+      byLayer[layer] = v;
+      const bucket = totals[layer]![v as keyof LayerFoldTotals] !== undefined ? (v as keyof LayerFoldTotals) : "other";
+      totals[layer]![bucket] += 1;
+    }
+    return {
+      trajectoryId: file.trajectoryId,
+      byLayer,
+      earlyExit: file.earlyExit,
+      layersEngaged: layersEngagedCount(file.layersEngaged),
+    };
+  });
+  return { rows, totals };
+}
+
+/** E-NEW-3 · D2-A — one detected cross-layer disagreement. NEVER auto-resolved. */
+export interface LayerConflict {
+  trajectoryId: string;
+  /** the disagreeing layers, e.g. ["L1","L2"]. */
+  layers: string[];
+  verdicts: Record<string, string>;
+  /** the judge's own note if it flagged the tension (honest emission). */
+  note?: string;
+}
+
+/**
+ * Detect outcome-vs-deep-layer disagreements (the OT-1 class): L1 pass with any
+ * of L2/L3/L4 fail, or L1 fail with ALL deep layers pass. Detection ONLY — the
+ * conflict routes to the human calibration queue; the GATE never reads it.
+ */
+export function detectLayerConflicts(files: MatrixVerdictFile[]): LayerConflict[] {
+  const out: LayerConflict[] = [];
+  for (const file of files) {
+    const lvs = file.layerVerdicts ?? [];
+    const get = (layer: string): LayerVerdict | undefined => lvs.find((x: LayerVerdict) => x.layer === layer);
+    const l1 = get("L1");
+    if (!l1) continue;
+    const deep = ["L2", "L3", "L4"].map((l) => get(l)).filter((x): x is LayerVerdict => x !== undefined);
+    const deepFails = deep.filter((x) => x.verdict === "fail");
+    const deepDecided = deep.filter((x) => x.verdict === "pass" || x.verdict === "fail");
+    if (l1.verdict === "pass" && deepFails.length > 0) {
+      const layers = ["L1", ...deepFails.map((x) => x.layer)];
+      out.push({
+        trajectoryId: file.trajectoryId,
+        layers,
+        verdicts: Object.fromEntries([["L1", "pass"], ...deepFails.map((x) => [x.layer, x.verdict])]),
+        note: deepFails.map((x) => x.note).filter(Boolean).join(" · ") || l1.note,
+      });
+    } else if (l1.verdict === "fail" && deepDecided.length > 0 && deepFails.length === 0) {
+      out.push({
+        trajectoryId: file.trajectoryId,
+        layers: ["L1", ...deepDecided.map((x) => x.layer)],
+        verdicts: Object.fromEntries([["L1", "fail"], ...deepDecided.map((x) => [x.layer, x.verdict])]),
+        note: l1.note,
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * COMPLETENESS LAW (S1.2) — every (criterion × complete-fidelity trajectory) cell
+ * must be accounted for: decided, abstained (uncertain), or explicitly `na` in the
+ * denseMap. A silently-missing cell THROWS — a criterion may never go unverdicted
+ * because nothing bound. INCOMPLETE (fidelity) trajectories are exempt by design.
+ */
+export function assertNoUnverdictedCriterion(criteria: MatrixCriterion[], files: MatrixVerdictFile[]): void {
+  const missing: string[] = [];
+  for (const file of files) {
+    if (file.fidelity && file.fidelity.complete === false) continue; // INCOMPLETE exempt
+    const judged = new Set(file.verdicts.map((v) => v.criterionId));
+    const dense = file.denseMap ?? {};
+    for (const c of criteria) {
+      if (judged.has(c.criterionId)) continue;
+      if (dense[c.criterionId] !== undefined) continue; // na / dense-mapped = accounted
+      missing.push(`${file.trajectoryId} × ${c.criterionId}`);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `COMPLETENESS LAW: ${missing.length} (criterion × trajectory) cell(s) unaccounted — a criterion ` +
+        `may NEVER be silently unverdicted (decide, abstain-with-reason, or mark na in denseMap). ` +
+        `First offenders: ${missing.slice(0, 5).join(" · ")}`,
+    );
+  }
+}
+
+/** MR-5 (E-NEW-9b) — fold the walks' emissions self-manifests into the run
+ *  data-completeness scorecard: expected-key coverage + every NAMED missing reason. */
+export interface EmissionsScorecard {
+  walksWithManifest: number;
+  walksTotal: number;
+  /** expected emission keys of the v3 contract. */
+  expectedKeys: string[];
+  /** key → number of complete-fidelity walks that emitted it. */
+  emittedCounts: Record<string, number>;
+  /** every named degrade: {trajectoryId, key, reason}. */
+  namedMissing: { trajectoryId: string; key: string; reason: string }[];
+  /** walks that emitted NO manifest at all (pre-v3 / defect — a named degrade itself). */
+  manifestAbsent: string[];
+}
+
+export const V3_EXPECTED_EMISSIONS: readonly string[] = [
+  "layerVerdicts",
+  "understanding",
+  "expectedTrajectory",
+  "agentSteps",
+  "judgeSteps",
+  "emissions",
+];
+
+export function foldEmissionsScorecard(files: MatrixVerdictFile[]): EmissionsScorecard {
+  const complete = files.filter((f) => !(f.fidelity && f.fidelity.complete === false));
+  const emittedCounts: Record<string, number> = {};
+  for (const k of V3_EXPECTED_EMISSIONS) emittedCounts[k] = 0;
+  const namedMissing: EmissionsScorecard["namedMissing"] = [];
+  const manifestAbsent: string[] = [];
+  for (const f of complete) {
+    // ground truth from the file itself (never trust-only the self-report):
+    const present = (k: string): boolean =>
+      (f as unknown as Record<string, unknown>)[k] !== undefined &&
+      (!Array.isArray((f as unknown as Record<string, unknown>)[k]) ||
+        ((f as unknown as Record<string, unknown>)[k] as unknown[]).length > 0);
+    for (const k of V3_EXPECTED_EMISSIONS) if (present(k)) emittedCounts[k]! += 1;
+    const manifest: WalkEmissions | undefined = f.emissions;
+    if (!manifest) {
+      manifestAbsent.push(f.trajectoryId);
+      continue;
+    }
+    for (const m of manifest.missing ?? []) {
+      namedMissing.push({ trajectoryId: f.trajectoryId, key: m.key, reason: m.reason });
+    }
+  }
+  return {
+    walksWithManifest: complete.length - manifestAbsent.length,
+    walksTotal: complete.length,
+    expectedKeys: [...V3_EXPECTED_EMISSIONS],
+    emittedCounts,
+    namedMissing,
+    manifestAbsent,
+  };
+}