@ggui-ai/ui-gen 0.13.0 → 0.15.0

package/dist/workflows.d.ts

@@ -1,7 +1,7 @@
 import { C as Classification } from './axes-CzLEMDeB.js';
 import { Workflow } from './harness/types-public.js';
 import '@ggui-ai/protocol';
-import './types-public-DIpjC-OA.js';
+import './types-public-CkNWEov9.js';
 import './types-BOvHNG7K.js';
 import './llm.js';
 import './policy.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/ui-gen",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "UI generation harness for ggui — the LLM system prompt, multi-turn coding loop, and evaluation engine that turn a DataContract into a React component. Implements the UiGenerator contract from @ggui-ai/mcp-server-core; consumed by @ggui-ai/mcp-server.",
   "license": "Apache-2.0",
   "keywords": [
@@ -183,14 +183,14 @@
     }
   },
   "peerDependencies": {
-    "@google/adk": "^0.5.0",
-    "@openai/agents": "^0.7.1",
+    "@google/adk": "^2.0.0",
+    "@openai/agents": "^0.17.0",
     "puppeteer-core": "^24.40.0 || ^25.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@ggui-ai/mcp-server-core": "0.13.0",
-    "@ggui-ai/protocol": "0.13.0",
-    "@ggui-ai/project-config": "0.13.0"
+    "@ggui-ai/mcp-server-core": "0.15.0",
+    "@ggui-ai/protocol": "0.15.0",
+    "@ggui-ai/project-config": "0.15.0"
   },
   "peerDependenciesMeta": {
     "@google/adk": {
@@ -210,34 +210,34 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/bedrock-sdk": "^0.32.1",
+    "@anthropic-ai/bedrock-sdk": "^0.33.3",
     "@anthropic-ai/claude-agent-sdk": "0.3.229",
-    "@anthropic-ai/sdk": "^0.116.0",
+    "@anthropic-ai/sdk": "^0.123.0",
     "@google/genai": "^2.8.0",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/react": "^16.0.0",
     "@testing-library/user-event": "^14.6.1",
     "@typescript-eslint/parser": "^8.0.0",
     "diff": "^8.0.3",
-    "esbuild": "^0.25.0",
+    "esbuild": "^0.28.2",
     "eslint": "^8.56.0",
     "eslint-plugin-react": "^7.37.0",
     "eslint-plugin-react-hooks": "^5.0.0",
     "happy-dom": "^20.8.9",
     "isomorphic-git": "^1.37.4",
     "memfs": "^4.56.11",
-    "openai": "^6.29.0",
+    "openai": "^7.9.0",
     "typescript": "^5.0.0",
     "zod": "^4.3.6",
-    "@ggui-ai/design": "0.13.0",
-    "@ggui-ai/gadgets": "0.13.0",
-    "@ggui-ai/ui-visual-tester": "0.13.0",
-    "@ggui-ai/sandbox": "0.13.0",
-    "@ggui-ai/wire": "0.13.0"
+    "@ggui-ai/gadgets": "0.15.0",
+    "@ggui-ai/sandbox": "0.15.0",
+    "@ggui-ai/ui-visual-tester": "0.15.0",
+    "@ggui-ai/wire": "0.15.0",
+    "@ggui-ai/design": "0.15.0"
   },
   "devDependencies": {
-    "@google/adk": "^0.5.0",
-    "@openai/agents": "^0.7.1",
+    "@google/adk": "^2.0.0",
+    "@openai/agents": "^0.17.0",
     "@sparticuz/chromium": "^149.0.0",
     "@types/eslint": "^9.6.1",
     "@types/node": "^22.0.0",
@@ -248,12 +248,12 @@
     "react-dom": "^19.0.0",
     "tsup": "^8.5.0",
     "vitest": "^3.2.6",
-    "@ggui-ai/mcp-server-core": "0.13.0",
-    "@ggui-ai/project-config": "0.13.0",
-    "@ggui-ai/protocol": "0.13.0"
+    "@ggui-ai/mcp-server-core": "0.15.0",
+    "@ggui-ai/project-config": "0.15.0",
+    "@ggui-ai/protocol": "0.15.0"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=22.0.0"
   },
   "author": "ggui contributors <hello@ggui.ai>",
   "scripts": {

package/src/adapters/provider-router.ts

@@ -30,6 +30,15 @@ export function getBedrockModelId(model: string): string {
     'anthropic/claude-haiku-4-5': 'us.anthropic.claude-haiku-4-5-20251001-v1:0',
     'anthropic/claude-sonnet-4-6': 'us.anthropic.claude-sonnet-4-6',
     'anthropic/claude-opus-4-6': 'us.anthropic.claude-opus-4-6-v1:0',
+    // Claude 5-family (ggui#706, strings verified 2026-09-02 against
+    // platform.claude.com; Bedrock base form `anthropic.<id>`, upcast to
+    // the cross-region profile). Explicit so the ids are pinned by test,
+    // not merely reachable through the generic fallback below.
+    'anthropic/claude-fable-5-1': 'us.anthropic.claude-fable-5-1',
+    'anthropic/claude-opus-5': 'us.anthropic.claude-opus-5',
+    'anthropic/claude-sonnet-5': 'us.anthropic.claude-sonnet-5',
+    // Legacy (still available; registry state `legacy`, not deprecated).
+    'anthropic/claude-fable-5': 'us.anthropic.claude-fable-5',
   };
   // Normalize the Bedrock dot-form opt-in (e.g. `anthropic.claude-haiku-4-5`,
   // produced when cloud-pod's `resolvePoolRoute` strips a `bedrock/` opt-in

package/src/boilerplate/system-prompt.ts

@@ -574,17 +574,17 @@ MANDATORY:
 1. NEVER use hardcoded hex colors like \`#7c3aed\` — ONLY \`var(--ggui-color-*)\` tokens.
 2. NEVER use CSS gradients with custom colors. If you need a gradient: \`linear-gradient(to bottom, var(--ggui-color-primary-500), var(--ggui-color-primary-700))\`.
 3. NEVER invent your own palette. The system provides primary, neutral, success, warning, error, and info — use ONLY these.
-4. NEVER include literal fallback values in color tokens — write \`var(--ggui-color-primary-600)\` bare, never \`var(--ggui-color-primary-600, #0284c7)\`. The runtime injects every token; a literal fallback paints the wrong brand exactly when the operator's theme matters most.
+4. NEVER include literal fallback values in ANY token reference — colors, spacing, typography, radius, shadows alike. Write \`var(--ggui-spacing-4)\` bare, never \`var(--ggui-spacing-4, 16px)\`; \`var(--ggui-color-primary-600)\` bare, never \`var(--ggui-color-primary-600, #0284c7)\`. The runtime injects every token; a literal fallback paints the wrong value exactly when the operator's theme matters most.
 
 Token categories:
 - Brand: \`var(--ggui-color-primary-600)\`, \`var(--ggui-color-primary-50)\`
 - Text: \`var(--ggui-color-onSurface)\`, \`var(--ggui-color-onSurfaceVariant)\`
 - Backgrounds: \`var(--ggui-color-surface)\`, \`var(--ggui-color-surfaceVariant)\`
 - Borders: \`var(--ggui-color-outline)\`
-- Spacing: \`var(--ggui-spacing-4, 16px)\`, \`var(--ggui-spacing-6, 24px)\`
-- Typography: \`var(--ggui-font-size-sm, 14px)\`, \`var(--ggui-font-weight-semibold, 600)\`
+- Spacing: \`var(--ggui-spacing-4)\`, \`var(--ggui-spacing-6)\`
+- Typography: \`var(--ggui-font-size-sm)\`, \`var(--ggui-font-weight-semibold)\`
 - Shadows: \`var(--ggui-shape-shadow-sm)\`, \`var(--ggui-shape-shadow-md)\`, \`var(--ggui-shape-shadow-lg)\`
-- Radius: \`var(--ggui-shape-radius-md, 8px)\`, \`var(--ggui-shape-radius-lg, 12px)\`
+- Radius: \`var(--ggui-shape-radius-md)\`, \`var(--ggui-shape-radius-lg)\`
 
 Prefer primitives' built-in styling props over inline styles when possible.
 

package/src/check/run-tier0.ts

@@ -15,6 +15,7 @@
 import ts from 'typescript';
 import type { DataContract } from '@ggui-ai/protocol';
 import { HOOK_NAME_RE, listContractGadgets } from '@ggui-ai/protocol';
+import { consumedTokenManifest } from '@ggui-ai/design/themes';
 import { validateAllContracts, type ContractIssue } from './contract-validation.js';
 import { typecheck } from './type-checker.js';
 import { lintReactHooks, type ReactLintDiagnostic } from './react-linter.js';
@@ -260,6 +261,17 @@ function detectCertainDoubleWiredActions(
   return issues;
 }
 
+/**
+ * The consumed-token manifest as a closed set (ggui#613 residual 3 —
+ * the generation-time closure leg of the #598 record). Every theme
+ * MUST define exactly these names (the coverage gate); a generated
+ * component may therefore consume ONLY these names. Anything else
+ * is a reference no theme is obligated to define, and under the s4
+ * fallback ban it paints nothing.
+ */
+const MANIFEST_TOKENS: ReadonlySet<string> = new Set(consumedTokenManifest);
+const TOKEN_REF_RE = /var\(\s*(--ggui-[a-zA-Z0-9-]+)/g;
+
 /** Map wire kind to the matching `@ggui-ai/wire` hook name. */
 const HOOK_NAME_FOR: Readonly<Record<WireKind, string>> = {
   action: 'useAction',
@@ -507,30 +519,45 @@ export async function runTier0Checks(
     // patterns flowing untouched. Asset-fixed brand colors get a
     // typed escape on Box (`assetColor` + `assetSemantic`) — see
     // T-4 follow-up.
+    // Literal fallback inside ANY token reference (ggui#598 slice 4
+    // origin-kill, generalized by ggui#613 residual 4 from color to
+    // every token): the runtime injects every token — colors, spacing,
+    // typography, radius, shadows — so a literal fallback can only
+    // ever paint default-brand pixels under a failed injection, which
+    // must be visible (unset) rather than silently default. The old
+    // hex-only exemption plus a remediation that suggested
+    // `var(--x, ${hex})` actively taught the model to launder invented
+    // values INTO fallbacks (adversarial-cycle find). A token-to-token
+    // fallback (`var(--a, var(--b))`) is not a literal — it stays on
+    // the manifest check alone.
+    const literalFallbackMatch = line.match(
+      /var\(\s*(--ggui-[a-zA-Z0-9-]+)\s*,\s*([^)]+)\)/,
+    );
+    const literalFallback =
+      literalFallbackMatch !== null &&
+      !literalFallbackMatch[2]!.trim().startsWith('var(')
+        ? { token: literalFallbackMatch[1]!, literal: literalFallbackMatch[2]!.trim() }
+        : null;
+    if (literalFallback !== null && !assetEscapedLines.has(lineNum)) {
+      issues.push({
+        tier: 0,
+        result: 'fail',
+        category: 'tokens',
+        subcategory: 'token-fallback',
+        severity: 'critical',
+        description: `Literal fallback "${literalFallback.literal}" inside a token reference — the runtime injects every token, and the fallback paints the wrong value exactly when the theme matters most.`,
+        fix: `Drop the fallback: write var(${literalFallback.token}) bare. If the token might not exist, that is a vocabulary problem to fix by choosing a token from the design-system docs, never by a literal.`,
+        line: lineNum,
+      });
+    }
+
     const hexMatch = line.match(/#[0-9a-fA-F]{3,8}\b/);
     if (hexMatch && !assetEscapedLines.has(lineNum)) {
-      // ggui#598 slice 4 (origin-kill): hex inside a `var(--ggui-*, #hex)`
-      // fallback is ALSO a violation now — the runtime injects every
-      // token, so a literal fallback can only ever paint default-brand
-      // pixels under a failed injection, which must be visible (unset)
-      // rather than silently sky-blue under someone's brand. The old
-      // exemption plus a remediation text that suggested
-      // `var(--x, ${hex})` actively taught the model to launder its
-      // invented hex INTO fallbacks (adversarial-cycle find).
-      const fallbackVarMatch = line.match(
-        /var\((--ggui-[a-zA-Z0-9-]+)\s*,[^)]*#[0-9a-fA-F]{3,8}/,
-      );
-      if (fallbackVarMatch) {
-        issues.push({
-          tier: 0,
-          result: 'fail',
-          category: 'tokens',
-          subcategory: 'token-fallback',
-          severity: 'critical',
-          description: `Literal fallback "${hexMatch[0]}" inside a token reference — the runtime injects every token, and the fallback paints the wrong brand exactly when the theme matters most.`,
-          fix: `Drop the fallback: write var(${fallbackVarMatch[1]}) bare. If the token might not exist, that is a vocabulary problem to fix by choosing a token from the design-system docs, never by a literal.`,
-          line: lineNum,
-        });
+      // A hex that lives inside a token fallback is already reported
+      // above as `token-fallback` — don't double-report it as
+      // `hex-color`.
+      if (literalFallback !== null && literalFallback.literal.includes(hexMatch[0])) {
+        // reported above
       } else if (!line.includes('// fallback')) {
         issues.push({
           tier: 0,
@@ -569,6 +596,31 @@ export async function runTier0Checks(
       });
     }
 
+    // Off-manifest token references (ggui#613 residual 3): a
+    // `var(--ggui-*)` whose name is outside the consumed-token
+    // manifest. The manifest is the closed vocabulary the prompt
+    // teaches AND the set every theme must define — so a name outside
+    // it is invented, and with literal fallbacks banned it renders
+    // UNSET. Fail, like the other token-contract violations; one issue
+    // per distinct name per line.
+    const offManifest = new Set<string>();
+    for (const m of line.matchAll(TOKEN_REF_RE)) {
+      const name = m[1]!;
+      if (!MANIFEST_TOKENS.has(name)) offManifest.add(name);
+    }
+    for (const name of offManifest) {
+      issues.push({
+        tier: 0,
+        result: 'fail',
+        category: 'tokens',
+        subcategory: 'off-manifest-token',
+        severity: 'critical',
+        description: `Token "${name}" is not in the design system's token manifest — no theme defines it, so it renders unset.`,
+        fix: `Choose a token that exists: the closed vocabulary is the manifest the design-system docs list (colors: var(--ggui-color-primary-500), var(--ggui-color-onSurface), …; spacing: var(--ggui-spacing-4); type: var(--ggui-font-size-sm)). Never invent a name and never add a literal fallback.`,
+        line: lineNum,
+      });
+    }
+
     // Raw CSS length on a spacing / radius prop — bypasses the design
     // scale. Same reasoning as the hardcoded-color checks above: a
     // literal `gap="8px"` defeats the theme's spacing scale exactly as
@@ -746,6 +798,41 @@ export async function runTier0Checks(
     );
   }
 
+  // ── Connection suppression (ggui#670 Phase 2) ────────────────
+  // `useRender().isConnected` is a LIVE read of the relay latch, and
+  // the ATTEMPT is the runtime's self-heal sensor (#440/#443
+  // attempt-always): a dispatch fired while the latch stands is how the
+  // runtime discovers the host can relay again. Binding `disabled` to
+  // the connection state strips the handler and blinds that sensor —
+  // the control stays dead after recovery. The runtime owns the dead
+  // zone's presentation (ggui#670 Phase 3: standing notice, then a
+  // per-gesture cue) — generated code never suppresses on it. Direct
+  // binding only, and only when the source reads
+  // `useRender` at all — a same-named `props.isConnected` (a device-
+  // status card) is not the connection state. Whole-source scan so a
+  // multi-line attribute is caught; the issue reports the attribute's
+  // line. The lookbehind keeps `aria-disabled={…}` (the idiom) out.
+  if (/\buseRender\s*\(/.test(sourceCode)) {
+    const suppressionRe = /(?<![\w-])disabled\s*=\s*\{([^}]*)\}/gs;
+    for (const m of sourceCode.matchAll(suppressionRe)) {
+      const expr = m[1]!;
+      if (!/\bisConnected\b/.test(expr)) continue;
+      const attrLine = sourceCode.slice(0, m.index ?? 0).split('\n').length;
+      issues.push({
+        tier: 0,
+        result: 'fail',
+        category: 'interactivity',
+        subcategory: 'connection-suppression',
+        severity: 'critical',
+        description:
+          `\`disabled\` is bound to the connection state (\`${expr.trim().replace(/\s+/g, ' ')}\`) — that strips the click handler, and the click is how the runtime detects that the host can relay actions again. The control stays dead after recovery.`,
+        fix:
+          'Leave the control enabled — never bind `disabled` to the connection state. The runtime presents the dead zone itself (a standing notice, then a per-gesture cue) and the attempt is how it detects recovery; a suppressed control stays dead after the host recovers.',
+        line: attrLine,
+      });
+    }
+  }
+
   // ── Optional props accessed without guard ──────────────────
   // Check if Props interface has optional fields that are accessed without ?. or ?? or &&
   const propsInterfaceMatch = sourceCode.match(/interface Props\s*\{([^}]+)\}/);

package/src/check/type-checker.ts

@@ -316,10 +316,18 @@ async function loadVfs(): Promise<Map<string, VfsEntry>> {
 /**
  * Try to resolve a relative import within the VFS.
  * Given `containingFile` (e.g. `node_modules/@ggui-ai/design/primitives/index.d.ts`)
- * and `importPath` (e.g. `./Card`), try:
+ * and `importPath` (e.g. `./Card` or, as every published declaration says
+ * since 0.15.0, `./Card.js`), try:
  *   - <resolved>.d.ts
  *   - <resolved>/index.d.ts
  *   - <resolved>.ts
+ * A `.js` / `.mjs` / `.cjs` extension on the specifier is the ESM
+ * convention for "the module that compiles to this file" — TypeScript's
+ * NodeNext maps `./Card.js` to `./Card.d.ts`, and so does this: the
+ * extension is stripped before the candidates are tried. Without that, a
+ * `.js`-suffixed re-export resolved to nothing, the imported names typed
+ * as `any`, and the checker reported zero errors on code it must reject
+ * (ggui 0.15.0 publish-gate, type-checker.test.ts).
  */
 function resolveRelativeInVfs(
   vfs: Map<string, VfsEntry>,
@@ -329,7 +337,9 @@ function resolveRelativeInVfs(
   // Strip leading '/' from containingFile — TS may prepend getCurrentDirectory()
   const normalized = containingFile.startsWith('/') ? containingFile.slice(1) : containingFile;
   const dir = path.posix.dirname(normalized);
-  const resolved = path.posix.normalize(`${dir}/${importPath}`);
+  // `./x.js` (`.mjs`, `.cjs`) names the declaration `./x.d.ts` — strip it.
+  const specifier = importPath.replace(/\.(?:m|c)?js$/, '');
+  const resolved = path.posix.normalize(`${dir}/${specifier}`);
 
   // Try .d.ts extension
   const withDts = `${resolved}.d.ts`;

package/src/evaluation/index.ts

@@ -23,6 +23,8 @@ export type {
   EvalCategory,
   EvalResult,
   EvalCriterion,
+  CriterionCoverage,
+  CriterionRunStatus,
   QualityMode,
   QualityConfig,
   AxisCheck,
@@ -30,6 +32,8 @@ export type {
 } from './types-public.js';
 export {
   CRITERIA,
+  LLM_EVAL_STATIC_CRITERIA,
+  notApplicableCoverage,
   DEFAULT_QUALITY_CONFIG,
   matches,
   priorityForIssue,

package/src/evaluation/llm-evaluator.ts

@@ -14,7 +14,14 @@
 // Caching: Anthropic ephemeral cache, OpenAI auto-cache, Google explicit cache.
 // Same system prompt across all 7 calls → first call caches, 6 remaining hit cache.
 
-import type { EvalIssue, EvalResult, EvalCategory } from './types-public.js';
+import type {
+  EvalIssue,
+  EvalResult,
+  EvalCategory,
+  CriterionCoverage,
+  CriterionRunStatus,
+} from './types-public.js';
+import { LLM_EVAL_STATIC_CRITERIA } from './types-public.js';
 import { createAgent } from '../harness/llm-router';
 import type { AgentConfig, LLMToolDef, LLMAgent } from '../harness/llm-router';
 import type { JsonObject } from '@ggui-ai/protocol';
@@ -518,13 +525,26 @@ interface CriterionResult {
   tier: 1 | 2;
   issues: EvalIssue[];
   pass: boolean;
+  /**
+   * Did this criterion actually produce a verdict? The evaluator
+   * fail-opens (`pass: true`) on LLM errors and missing tool calls so a
+   * flaky call never blocks generation — this field is what keeps that
+   * fail-open honest: `skipped` means `pass` carries zero evidence.
+   */
+  coverage: CriterionRunStatus;
+  /** Populated for `skipped` — why the criterion produced no verdict. */
+  skipReason?: string;
   tokens: { in: number; out: number };
   durationMs: number;
 }
 
-/** All valid categories for LLM evaluation */
-const TIER_1_CRITERIA = ['functionality', 'crash'] as const;
-const TIER_2_CRITERIA = ['interactivity', 'accessibility', 'layout', 'loading', 'visual'] as const;
+/**
+ * All valid categories for LLM evaluation — derived from the ONE static
+ * list in types-public so the coverage stamp here and the harness's
+ * bypass stamp (`notApplicableCoverage`) can never disagree on the set.
+ */
+const TIER_1_CRITERIA = LLM_EVAL_STATIC_CRITERIA.filter((c) => c.tier === 1).map((c) => c.criterion);
+const TIER_2_CRITERIA = LLM_EVAL_STATIC_CRITERIA.filter((c) => c.tier === 2).map((c) => c.criterion);
 
 async function evalCriterion(
   criterion: string,
@@ -557,6 +577,8 @@ async function evalCriterion(
         tier,
         issues: [],
         pass: true,
+        coverage: 'skipped',
+        skipReason: 'no tool call returned',
         tokens: { in: response.inputTokens, out: response.outputTokens },
         durationMs,
       };
@@ -614,18 +636,25 @@ async function evalCriterion(
       tier,
       issues,
       pass,
+      coverage: 'ran',
       tokens: { in: response.inputTokens, out: response.outputTokens },
       durationMs,
     };
   } catch (e) {
     const durationMs = Date.now() - start;
-    console.error(`[eval] ${criterion}: error — ${e instanceof Error ? e.message : e}`);
-    // On error, treat as pass to avoid blocking on flaky LLM calls
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`[eval] ${criterion}: error — ${message}`);
+    // On error, treat as pass to avoid blocking on flaky LLM calls.
+    // `coverage: 'skipped'` discloses the fail-open: this criterion
+    // produced NO verdict, and consumers must not read its `pass`
+    // membership as evidence.
     return {
       criterion,
       tier,
       issues: [],
       pass: true,
+      coverage: 'skipped',
+      skipReason: message,
       tokens: { in: 0, out: 0 },
       durationMs,
     };
@@ -809,22 +838,37 @@ export async function runLLMEvaluation(
 
   const wallMs = Date.now() - evalStart;
 
+  // Per-criterion coverage — one row per criterion, ALWAYS all of them,
+  // so a consumer can tell "ran clean" from "silently didn't run"
+  // (the fail-open paths above return pass:true with zero evidence).
+  const criteriaCoverage: CriterionCoverage[] = results.map((r) => ({
+    criterion: r.criterion,
+    tier: r.tier,
+    status: r.coverage,
+    ...(r.skipReason !== undefined ? { reason: r.skipReason } : {}),
+  }));
+  const skippedCount = criteriaCoverage.filter((c) => c.status === 'skipped').length;
+
   // Log per-criterion results
   for (const r of results) {
     const issueCount = r.issues.length;
-    const status = r.pass ? 'PASS' : r.tier === 1 ? 'FAIL' : (r.issues.some(i => i.result === 'fail') ? 'FAIL' : 'WARN');
+    const status = r.coverage === 'skipped'
+      ? 'SKIPPED'
+      : r.pass ? 'PASS' : r.tier === 1 ? 'FAIL' : (r.issues.some(i => i.result === 'fail') ? 'FAIL' : 'WARN');
     const issueLabel = issueCount > 0 ? ` (${issueCount} issue${issueCount > 1 ? 's' : ''})` : '';
     console.log(`[eval] ${r.criterion}: ${status}${issueLabel} ${(r.durationMs / 1000).toFixed(1)}s`);
   }
   console.log(
     `[eval] total: ${(wallMs / 1000).toFixed(1)}s wall (${totalCriteriaCount} parallel) | ` +
     `in=${totalIn} out=${totalOut} cached~=${cachedTokensEstimate} | ` +
-    `issues=${allIssues.length} pass=${passCategories.length}`,
+    `issues=${allIssues.length} pass=${passCategories.length}` +
+    (skippedCount > 0 ? ` skipped=${skippedCount}` : ''),
   );
 
   return {
     issues: allIssues,
     pass: passCategories,
+    criteriaCoverage,
     inputTokens: totalIn,
     outputTokens: totalOut,
   };

package/src/evaluation/types-public.ts

@@ -87,9 +87,88 @@ export interface RuntimeProbeMeta {
   readonly reason?: string;
 }
 
+/**
+ * Per-criterion execution status — three-valued so "the criterion
+ * silently produced no verdict" is never conflated with "the criterion
+ * ran clean", and neither is conflated with "not evaluated by design".
+ * Same doctrine and vocabulary family as `RuntimeProbeStatus` above.
+ *
+ *   - `ran`            — the LLM call completed and returned a verdict
+ *                        for this criterion; its findings (possibly
+ *                        none) are in `issues`.
+ *   - `skipped`        — the call errored or returned no tool call. The
+ *                        criterion carries ZERO evidence; the evaluator
+ *                        fail-opens it into `pass` to avoid blocking
+ *                        generation on flaky LLM calls, so consumers
+ *                        MUST consult this field before treating `pass`
+ *                        membership as a verdict. Counts AGAINST
+ *                        coverage.
+ *   - `not-applicable` — the evaluator was bypassed by design for this
+ *                        cell (e.g. the same-image low-risk bypass:
+ *                        axis checks clean, tier-1/2 never invoked).
+ *                        `reason` names the bypass. Excluded from
+ *                        coverage denominators — it is neither evidence
+ *                        nor a silent absence.
+ */
+export type CriterionRunStatus = "ran" | "skipped" | "not-applicable";
+
+/** Coverage row for one evaluation criterion of one eval run. */
+export interface CriterionCoverage {
+  readonly criterion: string;
+  readonly tier: 1 | 2;
+  readonly status: CriterionRunStatus;
+  /** Populated for `skipped` / `not-applicable` — why no verdict. */
+  readonly reason?: string;
+}
+
+/**
+ * The static criteria `runLLMEvaluation` runs, in stamp order — the
+ * ONE list both the evaluator's coverage stamp and the harness's
+ * bypass stamp derive from, so the two can never disagree on the set.
+ * Tier 1 = binary pass/fail gates; tier 2 = fail/warn/pass quality.
+ */
+export const LLM_EVAL_STATIC_CRITERIA: ReadonlyArray<{ readonly criterion: string; readonly tier: 1 | 2 }> = [
+  { criterion: "functionality", tier: 1 },
+  { criterion: "crash", tier: 1 },
+  { criterion: "interactivity", tier: 2 },
+  { criterion: "accessibility", tier: 2 },
+  { criterion: "layout", tier: 2 },
+  { criterion: "loading", tier: 2 },
+  { criterion: "visual", tier: 2 },
+];
+
+/**
+ * Coverage rows for a cell where the evaluator was BYPASSED BY DESIGN
+ * (never invoked) — one `not-applicable` row per static criterion, all
+ * carrying `reason`. Harness exits that skip tier-1/2 evaluation stamp
+ * this so the cell is neither a silent absence (field missing) nor
+ * evidence. Same shape contract as `runLLMEvaluation`'s stamp: always
+ * every criterion. Lives here (not in llm-evaluator) because the bypass
+ * exit runs before the evaluator module is lazily loaded.
+ */
+export function notApplicableCoverage(reason: string): CriterionCoverage[] {
+  return LLM_EVAL_STATIC_CRITERIA.map(({ criterion, tier }) => ({
+    criterion,
+    tier,
+    status: "not-applicable",
+    reason,
+  }));
+}
+
 export interface EvalResult {
   issues: EvalIssue[];
   pass: string[];
+  /**
+   * Per-criterion coverage for this eval run — one row per static
+   * criterion, ALWAYS all of them when present. Stamped by
+   * `runLLMEvaluation` (`ran` / `skipped`) and by the harness on
+   * evaluator-bypass exits (`not-applicable` + reason). The harness
+   * carries it unchanged through every later re-stamp of this result.
+   * Absent = coverage UNKNOWN (paths that predate the instrument, e.g.
+   * `parseEvalResponse` replays) — never assume `ran`, never assume
+   * bypass.
+   */
+  criteriaCoverage?: CriterionCoverage[];
   /**
    * Runtime-render probe execution meta. Stamped by the exit-decision
    * probe runner; absent on eval paths that never invoke the probe.

package/src/evaluation/visual-evaluator.ts

@@ -12,6 +12,7 @@
 // poor visual hierarchy, missing whitespace.
 
 import { build } from 'esbuild';
+import { getCssTokens } from '@ggui-ai/design/rendering';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { writeFileSync, mkdirSync, unlinkSync } from 'fs';
@@ -69,6 +70,22 @@ export interface VisualEvalContext {
  * Produces a self-contained IIFE that only needs React + ReactDOM from CDN.
  * Resolves @ggui-ai/design/* imports from the local monorepo packages.
  */
+/**
+ * The on-disk root of `@ggui-ai/design`, for the esbuild aliases that
+ * let JUDGED components resolve the same design source production
+ * ships. Exported for the ggui#613 regression pin: the previous inline
+ * `'..','..','..','packages','design'` resolved a pre-`oss/`-migration
+ * path (`oss/packages/packages/design`) that exists from NEITHER the
+ * src nor the dist layout — the visual leg's bundle broke silently at
+ * the migration. Three ups from `<pkg>/src/evaluation` (or
+ * `<pkg>/dist/evaluation`) is `oss/packages/`; the design package is
+ * its direct child.
+ */
+export function resolveDesignPackageDir(): string {
+  const selfDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(selfDir, '..', '..', '..', 'design');
+}
+
 async function bundleForRendering(
   compiledCode: string,
   sampleProps: Record<string, unknown>,
@@ -79,10 +96,7 @@ async function bundleForRendering(
   const componentFile = resolve(tmpDir, 'component.tsx');
   const entryFile = resolve(tmpDir, 'entry.tsx');
 
-  // Find the design package root — navigate from this file to packages/design/
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const designPkgDir = resolve(__dirname, '..', '..', '..', 'packages', 'design');
+  const designPkgDir = resolveDesignPackageDir();
 
   // Write the compiled component as a separate module
   writeFileSync(componentFile, compiledCode);
@@ -138,13 +152,21 @@ function buildRenderHTML(
   bundledCode: string,
   cssTokens?: string,
 ): string {
+  // Default to the design tokens production's no-theme branch injects
+  // (getCssTokens → default theme, light) — ggui#613: under the s4
+  // fallback ban the generated component's `var(--ggui-*)` references
+  // carry no literal fallbacks, so an un-injected judged render shows
+  // unset colors and the multimodal judge grades broken output. An
+  // explicit caller value still wins (theme-aware callers pass their
+  // own).
+  const tokens = cssTokens ?? getCssTokens();
   return `<!DOCTYPE html>
 <html>
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <style>
-    ${cssTokens ?? ''}
+    ${tokens}
     *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
     body {
       font-family: var(--ggui-font-family-sans, system-ui, -apple-system, sans-serif);