@ggui-ai/ui-gen 0.23.0 → 0.25.0

package/src/evaluation/ink-extent.ts

@@ -0,0 +1,200 @@
+/**
+ * The ink extent of a judge screenshot (ggui#1120): how far down the frame anything was painted, read
+ * from the pixels the judge already holds. `contentHeight` is the document's scroll height, floored at
+ * the viewport by definition — it can see overflow and never under-fill, and never a blank.
+ *
+ * The reading: the region's DOMINANT colour (its most common pixel) is the ground; a pixel is ink when
+ * any channel differs from it by more than {@link INK_TOLERANCE}; `lastInkRow` is the last region row
+ * with ink and `ratio` is `(lastInkRow + 1) / region.height`. Dominant, not the corners: an opening
+ * hero band makes the top corners content, and a host panel's rounded corners expose the scrim behind
+ * it (measured on the ggui#1083 judge frames — corner sampling read a card that fills as 1.0 and a
+ * panelled page as all ink).
+ *
+ * Only the ZERO is judged (`canvas-blank`, the judge's verdict): a region with no ink is one flat
+ * colour — the tree mounted and painted nothing, the mount-path class no compile-time check can reach
+ * (ggui#1104 / #1119). Every other value is reported, never scored: the corpus does not support a
+ * dead-space threshold (#1120).
+ *
+ * A PNG reader of exactly the judge's own captures — 8-bit RGB / RGBA, non-interlaced, `node:zlib`
+ * for the IDAT stream and the five scanline filters by hand — so a published package takes no image
+ * dependency. Any other PNG reads as unmeasurable (a reason), never as blank.
+ */
+import { inflateSync } from 'node:zlib';
+
+/** A channel difference at or below this is the same colour (anti-aliasing and compositing noise). */
+export const INK_TOLERANCE = 8;
+
+export interface PixelRegion {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface InkExtent {
+  /** `(lastInkRow + 1) / region.height`, rounded to 3 places; `0` when nothing differs from the ground. */
+  readonly ratio: number;
+  /** The last region row (0-based from the region's top) carrying ink; `null` when there is none — the blank. */
+  readonly lastInkRow: number | null;
+  /** The region read, in image px. */
+  readonly region: PixelRegion;
+  /** The dominant colour the ink was read against, `[r, g, b]`. */
+  readonly ground: readonly [number, number, number];
+}
+
+/** Why a capture could not be read — reported, never mistaken for a blank. */
+export interface InkUnreadable {
+  readonly reason: string;
+}
+
+export interface DecodedImage {
+  readonly width: number;
+  readonly height: number;
+  readonly channels: 3 | 4;
+  /** Row-major, `channels` bytes per pixel, scanline filters undone. */
+  readonly pixels: Uint8Array;
+}
+
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] as const;
+
+/** The PNG subset the judge's browser writes: 8-bit RGB (colour type 2) or RGBA (6), not interlaced. */
+export function decodePng(png: Uint8Array): DecodedImage | InkUnreadable {
+  const buf = Buffer.from(png.buffer, png.byteOffset, png.byteLength);
+  if (buf.length < 8 + 25) return { reason: `not a PNG: ${buf.length} bytes` };
+  for (let i = 0; i < PNG_SIGNATURE.length; i++) {
+    if (buf[i] !== PNG_SIGNATURE[i]) return { reason: 'not a PNG: signature mismatch' };
+  }
+  let width = 0;
+  let height = 0;
+  let channels: 3 | 4 | null = null;
+  const idat: Buffer[] = [];
+  let offset = 8;
+  while (offset + 8 <= buf.length) {
+    const length = buf.readUInt32BE(offset);
+    const type = buf.toString('latin1', offset + 4, offset + 8);
+    const start = offset + 8;
+    if (start + length + 4 > buf.length) return { reason: `truncated PNG: ${type} chunk runs past the end` };
+    const data = buf.subarray(start, start + length);
+    if (type === 'IHDR') {
+      if (length !== 13) return { reason: `malformed IHDR: ${length} bytes` };
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      const bitDepth = data[8];
+      const colorType = data[9];
+      const interlace = data[12];
+      if (bitDepth !== 8) return { reason: `unsupported PNG: bit depth ${bitDepth}` };
+      if (interlace !== 0) return { reason: 'unsupported PNG: interlaced' };
+      if (colorType === 2) channels = 3;
+      else if (colorType === 6) channels = 4;
+      else return { reason: `unsupported PNG: colour type ${colorType}` };
+    } else if (type === 'IDAT') {
+      idat.push(data);
+    } else if (type === 'IEND') {
+      break;
+    }
+    offset = start + length + 4;
+  }
+  if (channels === null) return { reason: 'malformed PNG: no IHDR' };
+  if (width === 0 || height === 0) return { reason: `empty PNG: ${width}×${height}` };
+  if (idat.length === 0) return { reason: 'malformed PNG: no IDAT' };
+  let raw: Buffer;
+  try {
+    raw = inflateSync(Buffer.concat(idat));
+  } catch (error) {
+    return { reason: `corrupt IDAT stream: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const stride = width * channels;
+  if (raw.length !== (stride + 1) * height) {
+    return { reason: `malformed PNG: ${raw.length} raw bytes for ${width}×${height}×${channels}` };
+  }
+  const pixels = new Uint8Array(stride * height);
+  const bpp = channels;
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)]!;
+    const inRow = y * (stride + 1) + 1;
+    const outRow = y * stride;
+    const prevRow = outRow - stride;
+    for (let i = 0; i < stride; i++) {
+      const x = raw[inRow + i]!;
+      const a = i >= bpp ? pixels[outRow + i - bpp]! : 0;
+      const b = y > 0 ? pixels[prevRow + i]! : 0;
+      const c = y > 0 && i >= bpp ? pixels[prevRow + i - bpp]! : 0;
+      let value: number;
+      switch (filter) {
+        case 0:
+          value = x;
+          break;
+        case 1:
+          value = x + a;
+          break;
+        case 2:
+          value = x + b;
+          break;
+        case 3:
+          value = x + ((a + b) >> 1);
+          break;
+        case 4: {
+          const p = a + b - c;
+          const pa = Math.abs(p - a);
+          const pb = Math.abs(p - b);
+          const pc = Math.abs(p - c);
+          value = x + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+          break;
+        }
+        default:
+          return { reason: `malformed PNG: scanline filter ${filter} at row ${y}` };
+      }
+      pixels[outRow + i] = value & 0xff;
+    }
+  }
+  return { width, height, channels, pixels };
+}
+
+/**
+ * The ink extent of a capture, read `insetPx` in from every edge — the judge's inset skips a host
+ * panel's gap, rounded corners and hairline ({@link JUDGE_INK_INSET_PX}); `0` reads the whole image.
+ */
+export function readInkExtent(png: Uint8Array, insetPx = 0): InkExtent | InkUnreadable {
+  const image = decodePng(png);
+  if ('reason' in image) return image;
+  const region: PixelRegion = { x: insetPx, y: insetPx, width: image.width - 2 * insetPx, height: image.height - 2 * insetPx };
+  if (insetPx < 0 || region.width <= 0 || region.height <= 0) {
+    return { reason: `an inset of ${insetPx}px leaves nothing of a ${image.width}×${image.height} image` };
+  }
+  const { channels, pixels, width } = image;
+  // The ground: the region's most common colour.
+  const counts = new Map<number, number>();
+  let ground = 0;
+  let groundCount = 0;
+  for (let y = region.y; y < region.y + region.height; y++) {
+    for (let x = region.x; x < region.x + region.width; x++) {
+      const i = (y * width + x) * channels;
+      const key = (pixels[i]! << 16) | (pixels[i + 1]! << 8) | pixels[i + 2]!;
+      const n = (counts.get(key) ?? 0) + 1;
+      counts.set(key, n);
+      if (n > groundCount) {
+        groundCount = n;
+        ground = key;
+      }
+    }
+  }
+  const gr = (ground >> 16) & 0xff;
+  const gg = (ground >> 8) & 0xff;
+  const gb = ground & 0xff;
+  let lastInkRow: number | null = null;
+  for (let y = region.y; y < region.y + region.height; y++) {
+    for (let x = region.x; x < region.x + region.width; x++) {
+      const i = (y * width + x) * channels;
+      if (
+        Math.abs(pixels[i]! - gr) > INK_TOLERANCE ||
+        Math.abs(pixels[i + 1]! - gg) > INK_TOLERANCE ||
+        Math.abs(pixels[i + 2]! - gb) > INK_TOLERANCE
+      ) {
+        lastInkRow = y - region.y;
+        break;
+      }
+    }
+  }
+  const ratio = lastInkRow === null ? 0 : Math.round(((lastInkRow + 1) / region.height) * 1000) / 1000;
+  return { ratio, lastInkRow, region, ground: [gr, gg, gb] };
+}

package/src/evaluation/theme-css.ts

@@ -5,10 +5,17 @@ import { composeThemeCss, getCssTokens } from '@ggui-ai/design/rendering';
  * The stylesheet a visual judge renders under for an app: the app's theme
  * composed the way the runtime composes it (`composeThemeCss`, layer `page`
  * — one composition, never a second), so a judged canvas paints the tokens a
- * visitor's page paints. Absent theme ⇒ the design's default tokens,
- * byte-for-byte what the judge used before.
+ * visitor's page paints. `themeId` is the registered ladder the app's theme
+ * sits on (the runtime's base layer); an unknown id composes the default
+ * ladder. Neither given ⇒ the design's default tokens, byte-for-byte what the
+ * judge used before.
  */
-export function cssTokensForAppTheme(theme: AppTheme | undefined, mode: 'light' | 'dark' = 'light'): string {
-  if (theme === undefined) return getCssTokens(mode);
-  return composeThemeCss({ layer: 'page', mode: theme.mode ?? mode, appTheme: theme });
+export function cssTokensForAppTheme(theme: AppTheme | undefined, mode: 'light' | 'dark' = 'light', themeId?: string): string {
+  if (theme === undefined && themeId === undefined) return getCssTokens(mode);
+  return composeThemeCss({
+    layer: 'page',
+    mode: theme?.mode ?? mode,
+    ...(themeId !== undefined ? { themeId } : {}),
+    ...(theme !== undefined ? { appTheme: theme } : {}),
+  });
 }

package/src/evaluation/types-public.ts

@@ -20,6 +20,7 @@
 
 export type Priority = "P0" | "P1" | "P2";
 
+import type { GenerationRuntimeProbeOutcome, GenerationRuntimeProbeStatus } from "@ggui-ai/mcp-server-core";
 import type { CanvasClass, DesignMode } from "../design-mode.js";
 
 // ─── Issue shape ───────────────────────────────────────────────────────────
@@ -63,8 +64,10 @@ export interface EvalIssue {
 }
 
 /**
- * Runtime-render probe execution status — three-valued so "the probe
- * never ran" is never conflated with "the probe ran clean".
+ * Runtime-render probe execution status — four-valued so "the probe
+ * never ran" is never conflated with "the probe ran clean". ONE union: the
+ * same values a generation's metadata reports (`GenerationRuntimeProbeStatus`
+ * in `@ggui-ai/mcp-server-core`), declared there and named here.
  *
  *   - `ran`           — probe executed; its findings (possibly none) are
  *                       in the issue stream under `runtime:*` subcategories.
@@ -83,7 +86,7 @@ export interface EvalIssue {
  *                       `hostLoad` say how long it ran and how busy the
  *                       host was, so a reader can tell the two cases apart.
  */
-export type RuntimeProbeStatus = "ran" | "infra-skipped" | "not-applicable" | "timed-out";
+export type RuntimeProbeStatus = GenerationRuntimeProbeStatus;
 
 /**
  * The host's 1-minute load average at a probe's start and end, beside the
@@ -98,21 +101,76 @@ export interface ProbeHostLoad {
 }
 
 /**
- * Probe execution meta stamped onto an `EvalResult` at the exit-decision
- * points that invoke the probe. Absence of this field means the eval
- * path never reached a probe invocation at all — consumers treat that
- * the same as not-run, never as a pass.
+ * The engine's own fields on a probe's meta, beside the outcome a
+ * generation's metadata reports: why a probe did not finish, its render
+ * time, the host's load around it. Present on every arm of
+ * {@link RuntimeProbeMeta}; each is absent when the probe had nothing to
+ * say about it.
  */
-export interface RuntimeProbeMeta {
-  readonly status: RuntimeProbeStatus;
+export interface RuntimeProbeMetaDetail {
   /** Populated for `infra-skipped` / `not-applicable` / `timed-out` — why the probe didn't finish. */
   readonly reason?: string;
-  /** `timed-out` only: how long the probe ran before it was stopped. */
-  readonly elapsedMs?: number;
+  /** `ran` only: the check's own render time, inside `elapsedMs`. */
+  readonly renderMs?: number;
   /** Host load around the probe, when it ran isolated (absent for an in-process probe). */
   readonly hostLoad?: ProbeHostLoad;
+  /** Time the check waited for a probe slot before it started, ms; present only when > 0 (ggui#1380 C2b). */
+  readonly queuedMs?: number;
 }
 
+/**
+ * Probe execution meta stamped onto an `EvalResult` at the exit-decision
+ * points that invoke the probe. Absence of this field means the eval
+ * path never reached a probe invocation at all — consumers treat that
+ * the same as not-run, never as a pass.
+ *
+ * ONE union with the generation metadata's probe outcome
+ * (`GenerationRuntimeProbeOutcome` in `@ggui-ai/mcp-server-core`, declared
+ * there and carried here with {@link RuntimeProbeMetaDetail} on every arm),
+ * so the round's stamp and the metadata's record cannot say different
+ * things (ggui#1380):
+ *
+ *   - `ran` + `verdict: 'pass'` — the probe executed and no check failed;
+ *   - `ran` + `verdict: 'fail'` — ANY check failed; `failChecks` lists the
+ *     distinct check kinds that did (`RenderCheckKind`, the engine's name
+ *     for the same union), never empty, in the order `RENDER_CHECK_KINDS`
+ *     declares them, parsed from the probe's own
+ *     `runtime:<check>[:<subject>]` issues;
+ *   - `timed-out` / `infra-skipped` / `not-applicable` — no verdict, and the
+ *     type carries none. `elapsedMs` (on every status that reached the
+ *     check) and `hostLoad` say how long it ran and how busy the host was.
+ *
+ * The verdict and the repair trigger are two different questions. The
+ * verdict is `fail` on any failing check. The one repair turn a probe-only
+ * round buys fires on a `render-no-throw` fail the engine recognises
+ * (`isRecoverableRenderCrash`) and on nothing else: on the PROBE-ONLY round a
+ * `fail` verdict whose checks are `prop-sensitivity`, `action-wiring` or any
+ * other kind is recorded here and never fed back. The same meta is stamped on
+ * the EVALUATION lane, where a `prop-sensitivity` fail buys that lane's own
+ * contract-feedback round (ggui#1261, `FEEDBACK_PROBE_CHECKS`) — a different
+ * turn under a different rule, not the repair turn.
+ */
+export type RuntimeProbeMeta = GenerationRuntimeProbeOutcome & RuntimeProbeMetaDetail;
+
+/**
+ * The one repair turn a probe-only round buys (ggui#1380). A serving
+ * deployment that wires the runtime probe and configures no evaluator runs
+ * the probe once after the coding turns; a render crash the engine
+ * recognises buys exactly one repair turn, then one re-probe. This records
+ * what came of it:
+ *   - `compiled: false` — the repair turn's code did not pass self-check, so
+ *     no re-probe ran (there is no `after`) and the pre-repair card is the
+ *     one served;
+ *   - `compiled: true` — the re-probe ran and `after` is its whole meta:
+ *     its status, its verdict when it ran, and the checks that still fail.
+ *     Whether the crash class the turn was bought for is still there is
+ *     `after.verdict === 'fail' && after.failChecks.includes('render-no-throw')`.
+ * The two arms are exclusive by type.
+ */
+export type RuntimeProbeRepair =
+  | { readonly attempted: true; readonly compiled: false; readonly trigger?: never }
+  | { readonly attempted: true; readonly compiled: true; readonly trigger: RuntimeProbeMeta };
+
 /**
  * Per-criterion execution status — three-valued so "the criterion
  * silently produced no verdict" is never conflated with "the criterion
@@ -226,6 +284,13 @@ export interface EvalResult {
    * probe runner; absent on eval paths that never invoke the probe.
    */
   runtimeProbe?: RuntimeProbeMeta;
+  /**
+   * The probe-only round's repair record (ggui#1380) — present only when a
+   * recoverable render crash bought the one repair turn. See
+   * {@link RuntimeProbeRepair}. `runtimeProbe` beside it is the re-probe's
+   * verdict when the repair compiled, else the pre-repair probe's.
+   */
+  runtimeProbeRepair?: RuntimeProbeRepair;
   /**
    * The contract-feedback round, when one fired this generation (ggui#1261):
    * which exit-probe findings bought it and the source as it stood when the
@@ -271,6 +336,108 @@ export interface CanvasJudgeRecord {
   readonly notes: string[];
 }
 
+// ─── Visual criteria (ggui#1436) ──────────────────────────────────────────
+// The judge's typed criteria block per canvas — report-only beside the score
+// until a later word flips a gate to it. Every field below is optional on the
+// stamps so yesterday's `eval.json` and an old judge answer still parse (N−1).
+import type { FetchShape, LayoutShape, RenderShape, RiskTier, StateShape, WriteShape } from "../classifier/axes.js";
+
+export type CriteriaSeverity = "must" | "should";
+export type CriteriaVerdict = "pass" | "fail" | "n/a";
+/** The method that produces a verdict: an instrument's measurement, the vision judge off the frame, or a person's eye. */
+export type CriteriaMethod = "instrument" | "judge" | "human";
+/** The method's readiness, as the bank's author wrote it — the only source of an `n/a` that is not the judge's own. */
+export type CriteriaStatus = "live" | "reference" | "planned" | "manual";
+/**
+ * How a criterion entered the selection: bank-level (`static`, an empty scope) or by the selector's
+ * rules for this card (`context`). A model PROPOSING a criterion at judge time is RESERVED and not a
+ * member until a consumer exists — it would be `should`-only, recorded verbatim, never a gate.
+ */
+export type CriteriaSource = "static" | "context";
+export type CriteriaChroma = "achromatic" | "chromatic" | "unknown";
+/** The classifier's shape axes, as hashed into the set id. */
+export interface CriteriaAxes {
+  render: RenderShape;
+  state: StateShape;
+  writes: WriteShape;
+  fetch: FetchShape;
+  layout: LayoutShape;
+}
+/** The selector's inputs, stored with the verdict so a reader recomputes `criteriaSetId` from the record alone. */
+export interface CriteriaContext {
+  canvas: CanvasClass;
+  hasActions: boolean;
+  riskTier: RiskTier;
+  axes: CriteriaAxes;
+  chroma: CriteriaChroma;
+  profilePresent: boolean;
+  /** The harness's shell as named; `unknown` when the round carries none. */
+  shell: string;
+  /** The caller's item kind (a bootstrap mint's `hello`); hashed when present. */
+  kind?: string;
+  /** The styling preset in force (the profile's aesthetic id); a recipe is selected only under its preset. */
+  preset?: string;
+}
+/** What was asked and why — recorded BEFORE the judge runs. Omission is the selector's decision. */
+export interface CriteriaSelection {
+  id: string;
+  source: CriteriaSource;
+  reason: string;
+}
+/** One criterion's verdict; `n/a` is the judge's answer ("cannot read this off the frame"), an unanswered id, a tie, or a method whose `status` is not live. */
+export interface CriterionVerdict {
+  id: string;
+  severity: CriteriaSeverity;
+  method: CriteriaMethod;
+  status: CriteriaStatus;
+  source: CriteriaSource;
+  verdict: CriteriaVerdict;
+  evidence: string;
+}
+export interface CriteriaBlock {
+  /** sha256(bank version | selector version | canonical context), 16 hex — the block's own digest. */
+  criteriaSetId: string;
+  bankVersion: string;
+  selectorVersion: string;
+  context: CriteriaContext;
+  selection: CriteriaSelection[];
+  verdicts: CriterionVerdict[];
+}
+/** The roll-up across canvases; a `must` at `n/a` is listed, never counted as a pass. */
+export interface CriteriaRollup {
+  mustFailed: string[];
+  shouldFailed: string[];
+  mustNa: string[];
+}
+
+/** ggui#1492 — a host"s frame round the inline card, as data. Colours are `#rrggbb`; the ring"s `alpha` is 0..1. */
+export interface HostInlineFrame {
+  /** The frame"s surface — what shows behind a transparent card, and under the floor"s residual. */
+  readonly surface: string;
+  /** The room the frame sits in (the page ground round it). */
+  readonly ground: string;
+  readonly ring: { readonly widthPx: number; readonly color: string; readonly alpha: number };
+  readonly radiusPx: number;
+  /** The host"s minimum frame height: a card shorter than it sits in a frame this tall, and the visitor sees the rest as void. */
+  readonly minHeightPx?: number;
+}
+/** ggui#1492 — how a host presents one canvas: the label the judge is told, the page ground, and (the inline card only) its frame. */
+export interface CanvasHostPresentation {
+  readonly label: string;
+  /** The page ground under a fill canvas"s panel; the inline card"s ground lives on its {@link HostInlineFrame}. */
+  readonly ground?: string;
+  readonly frame?: HostInlineFrame;
+}
+/** ggui#1492 — why the judge did not draw a canvas's host presentation. The codes are the lane reader's own. */
+export type HostPresentationIgnoredReason = "label_missing" | "color_not_hex" | "frame_off_inline" | "frame_malformed" | "ground_on_inline";
+/**
+ * ggui#1492 — what the judge DID with a canvas's host presentation, read from the judge itself: `applied` carries
+ * the presentation it drew, `ignored` the reason it drew none. Absent when the caller supplied no presentation.
+ */
+export type CanvasPresentationOutcome =
+  | { readonly status: "applied"; readonly applied: CanvasHostPresentation }
+  | { readonly status: "ignored"; readonly reason: HostPresentationIgnoredReason };
+
 export interface CanvasVisualSummary {
   canvas: CanvasClass;
   viewport: { width: number; height: number };
@@ -282,8 +449,19 @@ export interface CanvasVisualSummary {
   contentHeight: number | null;
   /** `contentHeight > viewport.height` — measured on every canvas, judged per `canvasFitPolicy`. */
   overflow: boolean;
+  /**
+   * ggui#1120 — how far down the capture anything was painted: the last inked row over the measured
+   * region's height (inside a drawn host panel's chrome on md/lg/xl), read from the screenshot's
+   * pixels against their dominant colour. `0` is the blank the judge fails (`canvas-blank`); every
+   * other value is reported, never scored. `null` when the capture could not be read.
+   */
+  inkRatio: number | null;
   /** How `score` was reached — always present (ggui#1072). */
   judge: CanvasJudgeRecord;
+  /** ggui#1436 — the typed criteria block, when a bank was configured; report-only. */
+  criteria?: CriteriaBlock;
+  /** ggui#1492 — what the judge did with this canvas's host presentation, when one was supplied. */
+  presentation?: CanvasPresentationOutcome;
   /**
    * How the judge composed the mount (ggui#1100): `'fill'` on every
    * fullscreen canvas — the served runtime's fit, the root stretched to
@@ -320,6 +498,8 @@ export interface VisualEvalSummary {
   design?: { readonly src: string; readonly srcSha256: string };
   /** The mode the judge's tokens were composed in, when the caller said (ggui#1076). */
   themeMode?: 'light' | 'dark';
+  /** ggui#1436 — the criteria roll-up across canvases, when any canvas carries a block; report-only. */
+  criteria?: CriteriaRollup;
 }
 
 // ─── Quality mode ──────────────────────────────────────────────────────────
@@ -345,6 +525,7 @@ export const DEFAULT_QUALITY_CONFIG: QualityConfig = {
 // `./axis-checks/`.
 
 import type { DataContract } from "@ggui-ai/protocol";
+import type { JsonObject } from "@ggui-ai/protocol";
 import type { AxisVector, Classification } from "../classifier/axes.js";
 import type { AxisKey } from "../fragments/index.js";
 
@@ -371,6 +552,14 @@ export interface AxisCheckInput {
    * default (a silent `lg` would be the same guess with a nicer face).
    */
   canvas?: CanvasClass;
+  /**
+   * The props the probe and the judge RENDERED the source with (ggui#1285) — a bootstrap order's
+   * `sampleProps`, the bench commit's fixture. They are judging data, not the request: a literal in
+   * the source that equals one of these values, and that the request never stated, is baked copy a
+   * visitor sees whenever the agent leaves the prop out. Populated on the served loop and at
+   * auto-commit; ABSENT where the caller has none — the check stands down, it never guesses.
+   */
+  fixtureProps?: JsonObject;
 }
 
 /**

package/src/evaluation/types.ts

@@ -33,6 +33,13 @@ export interface EvaluationIssue {
 /**
  * Result of a single evaluation round.
  */
+/** One judge answer to a criterion (ggui#1436), as parsed — before the K-majority. */
+export interface CriteriaAnswer {
+  id: string;
+  verdict: 'pass' | 'fail' | 'n/a';
+  evidence: string;
+}
+
 export interface EvaluationResult {
   /** Whether the component passed the quality threshold */
   passed: boolean;
@@ -48,6 +55,8 @@ export interface EvaluationResult {
   inputTokens?: number;
   /** Output tokens consumed by the evaluation LLM call */
   outputTokens?: number;
+  /** ggui#1436 — the judge's criteria answers, when the prompt asked for them; never part of the score. */
+  criteriaAnswers?: CriteriaAnswer[];
 }
 
 /**