@ggui-ai/ui-gen 0.23.0 → 0.24.0

package/src/create-ui-generator.ts

@@ -31,66 +31,96 @@
  * Callers who want a lightweight single-shot path can build it
  * themselves.
  */
-import type { SingleComponentParams } from './harness/runtime.js';
+import type { SingleComponentParams } from "./harness/runtime.js";
 import type {
   GadgetDescriptor,
   GenerationError,
   JsonObject,
   GeneratorId,
   ModelRef,
-} from '@ggui-ai/protocol';
-import { isGeneratorId, modelRefOfRoute } from '@ggui-ai/protocol';
-import type { GadgetCatalogAdapter } from '@ggui-ai/gadgets';
+} from "@ggui-ai/protocol";
+import { isGeneratorId, modelRefOfRoute } from "@ggui-ai/protocol";
+import type { GadgetCatalogAdapter } from "@ggui-ai/gadgets";
 import type {
   GenerationMetadata,
+  GenerationRuntimeProbe,
+  GenerationRuntimeProbeOutcome,
+  GenerationRuntimeProbeRepair,
   GeneratorTier,
   LlmProvider,
   UiGenerateInput,
   UiGenerateResult,
   UiGenerator,
-} from '@ggui-ai/mcp-server-core';
+} from "@ggui-ai/mcp-server-core";
 import {
   formatGeneratorSlug,
   isValidGeneratorSlug,
   parseGeneratorSlug,
-} from '@ggui-ai/mcp-server-core';
-import { createGeneratorTools } from './adapters/index.js';
-import { dispatchGeneration } from './adapters/generation-dispatch.js';
-import { generatorBuild } from './generator-build.js';
-import { hasProfile } from './boilerplate/styling-profile.js';
-import { effortDials } from './effort.js';
-import type { ProviderName } from './adapters/types.js';
-import type { GenerationResult } from './harness/result-types.js';
+} from "@ggui-ai/mcp-server-core";
+import { createGeneratorTools } from "./adapters/index.js";
+import { dispatchGeneration } from "./adapters/generation-dispatch.js";
+import {
+  createRuntimeRenderCheck,
+  type RuntimeRenderProbeConfig,
+} from "./harness/check/runtime-render/adapter.js";
+import { generatorBuild } from "./generator-build.js";
+import { hasProfile } from "./boilerplate/styling-profile.js";
+import { effortDials } from "./effort.js";
+import type { ProviderName } from "./adapters/types.js";
+import type { GenerationResult } from "./harness/result-types.js";
 import {
   canvasForRenderingContext,
   injectContracts,
   injectRenderingContext,
   injectVariance,
-} from './contract-context.js';
-import type { RenderingContext } from './contract-context.js';
-import type { DesignMode } from './design-mode.js';
-import { DEFAULT_DESIGN_MODE } from './design-mode.js';
-import { resolveRoute, applyRouteToEnv } from './adapters/provider-router.js';
-import type { QualityConfig } from './evaluation/types-public.js';
-import type { EvaluationConfig } from './evaluation/types.js';
-import type { AgentConfig } from './harness/llm-router.js';
+} from "./contract-context.js";
+import type { RenderingContext } from "./contract-context.js";
+import type { DesignMode } from "./design-mode.js";
+import { DEFAULT_DESIGN_MODE } from "./design-mode.js";
+import { resolveRoute, applyRouteToEnv } from "./adapters/provider-router.js";
+import type { QualityConfig, RuntimeProbeMeta, RuntimeProbeRepair } from "./evaluation/types-public.js";
+import type { EvaluationConfig } from "./evaluation/types.js";
+import type { AgentConfig } from "./harness/llm-router.js";
 
 /** The slug for the OSS default seed generator. */
-const DEFAULT_TIER: GeneratorTier = 'default';
-const DEFAULT_MODEL: ModelRef = 'anthropic/claude-haiku-4-5';
+const DEFAULT_TIER: GeneratorTier = "default";
+const DEFAULT_MODEL: ModelRef = "anthropic/claude-haiku-4-5";
 
 export interface CreateUiGeneratorOptions {
   /**
-   * Wire `DEFAULT_RUNTIME_RENDER_CHECK` into the harness's check leg.
-   * When `true`, every coding turn ends with a happy-dom runtime-render
-   * probe that catches contract-wiring bugs (missing `useAction()`,
-   * wrong stream channel name, etc.).
+   * Wire the runtime-render check into the harness's check leg — one
+   * instance per generator, built from `runtimeRenderProbe` (the default
+   * bounds when it is absent). When `true`, the runtime-render probe runs
+   * ONCE at the exit decision,
+   * after the coding turns, in an isolated subprocess: it mounts the
+   * compiled component against the contract and catches crash-class and
+   * contract-wiring bugs (a render that throws, a missing `useAction()`,
+   * a wrong stream channel name). It is never on the per-turn hot path.
+   *
+   * Without an `evaluation` config the round is observe + one repair turn
+   * (ggui#1380): a recoverable render crash buys exactly one repair turn
+   * and one re-probe, then the generation serves what it has; a probe that
+   * timed out, could not run, or had nothing to probe never blocks and
+   * never repairs. The probe's status and timing ride the result's
+   * metadata (`runtimeProbe`, `evalMs`). With an `evaluation` config the
+   * probe is the evaluation round's exit gate instead.
    *
-   * Default: `false` for OSS — keeps cold-start light. The probe pulls
-   * happy-dom + @testing-library on first use (~700-1500ms cold). Bench
-   * enables it via dispatch's own default for stricter quality gating.
+   * Default: `false` — keeps cold-start light. The probe pulls happy-dom
+   * + @testing-library on first use (~700-1500ms cold). A serving
+   * deployment that wants the probe's verdict on every card sets it.
    */
   readonly enableRuntimeRender?: boolean;
+  /**
+   * How the runtime-render probe runs its isolated worker (ggui#1380). A
+   * serving deployment sets the probe's wall-clock bound, worker heap and
+   * concurrency here; the defaults are the evaluation lane's (30 s, 512 MB,
+   * no concurrency cap). The generator builds ONE check from it and hands
+   * that instance to every generation it dispatches — the concurrency cap
+   * lives on the instance, so it bounds the workers this generator has
+   * live at once. Only read when `enableRuntimeRender` is on. Never part
+   * of the prompt or the identity.
+   */
+  readonly runtimeRenderProbe?: RuntimeRenderProbeConfig;
   /** Maximum coding attempts per generation pass. */
   readonly maxAttempts?: number;
   /** Maximum evaluation rounds. */
@@ -108,7 +138,7 @@ export interface CreateUiGeneratorOptions {
    * stylesheet to render under). Forwarded verbatim; never part of the
    * prompt or the identity. Default: none — the round runs as today.
    */
-  readonly visualEvaluation?: SingleComponentParams['visualEvaluation'];
+  readonly visualEvaluation?: SingleComponentParams["visualEvaluation"];
   /** Quality config controlling eval tiers + improvement behavior. */
   readonly qualityConfig?: QualityConfig;
   /**
@@ -189,7 +219,7 @@ export interface CreateUiGeneratorOptions {
    * request. Absent (default) is a no-op — retries still happen and
    * still log via `console.warn`, just without a caller-side hook.
    */
-  readonly onRetry?: AgentConfig['onRetry'];
+  readonly onRetry?: AgentConfig["onRetry"];
   /**
    * Generation observer. Invoked once per successful `generate()` with
    * the FULL harness result — source, compiled code, token counters,
@@ -221,11 +251,10 @@ export interface CreateUiGeneratorOptions {
   readonly designMode?: DesignMode;
 }
 
-export function createUiGenerator(
-  options: CreateUiGeneratorOptions = {},
-): UiGenerator {
+export function createUiGenerator(options: CreateUiGeneratorOptions = {}): UiGenerator {
   const {
     enableRuntimeRender = false,
+    runtimeRenderProbe,
     maxAttempts,
     maxEvalRounds,
     evaluation,
@@ -237,6 +266,11 @@ export function createUiGenerator(
     onGenerated,
     designMode,
   } = options;
+  // ggui#1380 — ONE runtime-render check per generator: the instance owns
+  // the probe's concurrency cap, so it must outlive a single generation.
+  const runtimeRender = enableRuntimeRender
+    ? createRuntimeRenderCheck(runtimeRenderProbe)
+    : undefined;
 
   const identity = resolveIdentity(options);
 
@@ -273,9 +307,9 @@ export function createUiGenerator(
         });
       } catch (err) {
         return failWithoutMetadata(input, identity.slug, startedAt, {
-          code: 'PRODUCTION_FAILED',
+          code: "PRODUCTION_FAILED",
           message: err instanceof Error ? err.message : String(err),
-          details: { kind: 'route-resolution-failed' },
+          details: { kind: "route-resolution-failed" },
         });
       }
 
@@ -307,16 +341,16 @@ export function createUiGenerator(
       // flag is the only way the decision reaches `createAgent` /
       // `createVisionAgent` (which select the login client on it).
       const routeOverride =
-        route.auth === 'claude-code-login'
+        route.auth === "claude-code-login"
           ? { claudeCodeLogin: true }
           : disableEnvMutation
             ? {
                 apiKey:
-                  route.env['ANTHROPIC_API_KEY'] ??
-                  route.env['OPENAI_API_KEY'] ??
-                  route.env['GEMINI_API_KEY'] ??
-                  route.env['OPENROUTER_API_KEY'],
-                useBedrock: route.env['CLAUDE_CODE_USE_BEDROCK'] === '1',
+                  route.env["ANTHROPIC_API_KEY"] ??
+                  route.env["OPENAI_API_KEY"] ??
+                  route.env["GEMINI_API_KEY"] ??
+                  route.env["OPENROUTER_API_KEY"],
+                useBedrock: route.env["CLAUDE_CODE_USE_BEDROCK"] === "1",
               }
             : undefined;
 
@@ -342,11 +376,9 @@ export function createUiGenerator(
         // descriptors stay byte-identical).
         const canvas = rendering ? canvasForRenderingContext(rendering) : undefined;
         const shellType = harnessShellForRendering(rendering);
-        const promptWithVariance = injectVariance(
-          promptWithRendering,
-          input.variance,
-          { profileDeclared: hasProfile(input.profile) },
-        );
+        const promptWithVariance = injectVariance(promptWithRendering, input.variance, {
+          profileDeclared: hasProfile(input.profile),
+        });
 
         // Resolve appGadgets by precedence:
         //   1. input.appGadgets (caller pre-fetched, handler path)
@@ -359,14 +391,10 @@ export function createUiGenerator(
           input.appGadgets !== undefined
             ? input.appGadgets
             : gadgetCatalog !== undefined && input.appId !== undefined
-            ? await gadgetCatalog.list(input.appId)
-            : undefined;
+              ? await gadgetCatalog.list(input.appId)
+              : undefined;
 
-        const userPrompt = injectContracts(
-          promptWithVariance,
-          input.contract,
-          resolvedAppGadgets,
-        );
+        const userPrompt = injectContracts(promptWithVariance, input.contract, resolvedAppGadgets);
 
         // `effort` (ggui#1059): a named level's dials override the
         // deployment's options for THIS generation; absent ⇒ untouched.
@@ -375,7 +403,9 @@ export function createUiGenerator(
         const effectiveMaxAttempts = dials?.maxAttempts ?? maxAttempts;
         const effectiveMaxEvalRounds = dials?.maxEvalRounds ?? maxEvalRounds;
         const effectiveEvaluation =
-          dials !== undefined && evaluation !== undefined ? { ...evaluation, maxRounds: dials.maxEvalRounds } : evaluation;
+          dials !== undefined && evaluation !== undefined
+            ? { ...evaluation, maxRounds: dials.maxEvalRounds }
+            : evaluation;
         const effectiveVisualEvaluation =
           dials !== undefined && visualEvaluation !== undefined
             ? { ...visualEvaluation, passThreshold: dials.selfEvalPassThreshold }
@@ -389,21 +419,22 @@ export function createUiGenerator(
           ...(input.contract ? { contract: input.contract } : {}),
           originalPrompt: input.request.prompt,
           ...(effectiveMaxAttempts !== undefined ? { maxAttempts: effectiveMaxAttempts } : {}),
-          ...(effectiveMaxEvalRounds !== undefined ? { maxEvalRounds: effectiveMaxEvalRounds } : {}),
+          ...(effectiveMaxEvalRounds !== undefined
+            ? { maxEvalRounds: effectiveMaxEvalRounds }
+            : {}),
           ...(effectiveEvaluation !== undefined ? { evaluation: effectiveEvaluation } : {}),
-          ...(effectiveVisualEvaluation !== undefined ? { visualEvaluation: effectiveVisualEvaluation } : {}),
-          ...(qualityConfig !== undefined ? { qualityConfig } : {}),
-          ...(resolvedAppGadgets !== undefined
-            ? { appGadgets: resolvedAppGadgets }
+          ...(effectiveVisualEvaluation !== undefined
+            ? { visualEvaluation: effectiveVisualEvaluation }
             : {}),
+          ...(qualityConfig !== undefined ? { qualityConfig } : {}),
+          ...(resolvedAppGadgets !== undefined ? { appGadgets: resolvedAppGadgets } : {}),
           // Forward the third-party wrapper `.d.ts` map the render
           // handler pre-fetched. Reaches both the code-gen prompt's
           // `Type:` lines and the coding-agent typecheck overlay via
           // `dispatchGeneration`.
-          ...(input.gadgetTypes !== undefined
-            ? { gadgetTypes: input.gadgetTypes }
-            : {}),
+          ...(input.gadgetTypes !== undefined ? { gadgetTypes: input.gadgetTypes } : {}),
           enableRuntimeRender,
+          ...(runtimeRender !== undefined ? { runtimeRender } : {}),
           ...(routeOverride !== undefined ? { routeOverride } : {}),
           ...(onRetry !== undefined ? { onRetry } : {}),
           ...(designMode !== undefined ? { designMode } : {}),
@@ -417,6 +448,8 @@ export function createUiGenerator(
 
         onGenerated?.(result);
 
+        const runtimeProbe = metadataRuntimeProbe(result);
+        const evalMs = metadataEvalMs(result);
         const metadata: GenerationMetadata = {
           provider: input.llm.provider,
           generator: identity.slug,
@@ -437,6 +470,10 @@ export function createUiGenerator(
           ...(result.cacheCreationTokens !== undefined
             ? { cacheCreationTokens: result.cacheCreationTokens }
             : {}),
+          // ggui#1380 — the runtime probe's record and the eval rounds' wall,
+          // when the harness ran a round; absent stays absent.
+          ...(runtimeProbe !== undefined ? { runtimeProbe } : {}),
+          ...(evalMs !== undefined ? { evalMs } : {}),
         };
 
         return {
@@ -451,12 +488,12 @@ export function createUiGenerator(
         };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        const details: JsonObject = { kind: 'harness-failed' };
-        if (err instanceof Error && err.stack) details['stack'] = err.stack;
+        const details: JsonObject = { kind: "harness-failed" };
+        if (err instanceof Error && err.stack) details["stack"] = err.stack;
         return {
           ok: false,
           error: {
-            code: 'PRODUCTION_FAILED',
+            code: "PRODUCTION_FAILED",
             message,
             details,
           },
@@ -488,11 +525,9 @@ function resolveIdentity(opts: CreateUiGeneratorOptions): {
   tier: GeneratorTier;
   model: ModelRef;
 } {
-  const hasSlug = typeof opts.slug === 'string' && opts.slug.length > 0;
+  const hasSlug = typeof opts.slug === "string" && opts.slug.length > 0;
   if (hasSlug && opts.tier !== undefined) {
-    throw new Error(
-      'createUiGenerator: pass either { slug } or { tier } — not both.',
-    );
+    throw new Error("createUiGenerator: pass either { slug } or { tier } — not both.");
   }
   const model = opts.model ?? DEFAULT_MODEL;
   if (hasSlug) {
@@ -500,7 +535,7 @@ function resolveIdentity(opts: CreateUiGeneratorOptions): {
     const parsed = parseGeneratorSlug(slug);
     if (!parsed || !isGeneratorId(slug)) {
       throw new Error(
-        `createUiGenerator: slug ${JSON.stringify(slug)} is not a valid ui-gen-<tier> identifier.`,
+        `createUiGenerator: slug ${JSON.stringify(slug)} is not a valid ui-gen-<tier> identifier.`
       );
     }
     return { slug, tier: parsed.tier, model };
@@ -512,23 +547,80 @@ function resolveIdentity(opts: CreateUiGeneratorOptions): {
     // so a slug it returns must parse. Defensive check kept to surface
     // any future drift between the two helpers.
     throw new Error(
-      `createUiGenerator: formatted slug ${JSON.stringify(slug)} round-trips as invalid — formatGeneratorSlug/isValidGeneratorSlug drift.`,
+      `createUiGenerator: formatted slug ${JSON.stringify(slug)} round-trips as invalid — formatGeneratorSlug/isValidGeneratorSlug drift.`
     );
   }
   return { slug, tier, model };
 }
 
+/**
+ * ggui#1380 — one probe's meta, projected onto the metadata's outcome ARM BY
+ * ARM: the outcome fields (`status`, `verdict`, `failChecks`, `elapsedMs`)
+ * are copied; the engine's own detail (`reason`, `renderMs`, `hostLoad`)
+ * stays on the harness result. No cast — each arm is rebuilt as a literal of
+ * the target arm, so a field the metadata does not carry cannot ride along
+ * and a field the arm requires cannot be dropped. Absent stays absent.
+ */
+function metadataProbeOutcome(meta: RuntimeProbeMeta): GenerationRuntimeProbeOutcome {
+  const elapsed = {
+    ...(meta.elapsedMs !== undefined ? { elapsedMs: meta.elapsedMs } : {}),
+    ...(meta.queuedMs !== undefined ? { queuedMs: meta.queuedMs } : {}),
+  };
+  if (meta.status !== "ran") return { status: meta.status, ...elapsed };
+  if (meta.verdict === "pass") return { status: "ran", verdict: "pass", ...elapsed };
+  return { status: "ran", verdict: "fail", failChecks: meta.failChecks, ...elapsed };
+}
+
+/**
+ * ggui#1380 — the repair record, arm by arm: `compiled: false` is carried as
+ * is (no re-probe, so no after); `compiled: true` carries the re-probe's meta
+ * projected with the same function as the record's own outcome.
+ */
+function metadataProbeRepair(repair: RuntimeProbeRepair): GenerationRuntimeProbeRepair {
+  return repair.compiled
+    ? { attempted: true, compiled: true, trigger: metadataProbeOutcome(repair.trigger) }
+    : { attempted: true, compiled: false };
+}
+
+/**
+ * ggui#1380 — the harness result's probe record, projected onto the metadata
+ * a host reads. The outcome fields are the LAST probe's (the re-probe's when
+ * the repair compiled, else the pre-repair probe's — exactly what the harness
+ * stamps on `evalResult.runtimeProbe`), and `repair` is present only when a
+ * repair turn was bought. Absent when no probe ran — never a default status.
+ */
+function metadataRuntimeProbe(result: GenerationResult): GenerationRuntimeProbe | undefined {
+  const probe = result.evalResult?.runtimeProbe;
+  if (probe === undefined) return undefined;
+  const repair = result.evalResult?.runtimeProbeRepair;
+  return {
+    ...metadataProbeOutcome(probe),
+    ...(repair !== undefined ? { repair: metadataProbeRepair(repair) } : {}),
+  };
+}
+
+/**
+ * ggui#1380 — the eval rounds' wall-clock, present only when a round ran:
+ * a generation with no round has nothing to time, and the field stays
+ * absent rather than reporting a structural 0.
+ */
+function metadataEvalMs(result: GenerationResult): number | undefined {
+  const breakdown = result.breakdown;
+  if (breakdown === undefined || breakdown.evalRounds === 0) return undefined;
+  return breakdown.evalMs;
+}
+
 function mapLlmProviderToDispatchProvider(provider: LlmProvider): ProviderName {
   switch (provider) {
-    case 'anthropic':
-    case 'bedrock':
-      return 'claude';
-    case 'openai':
-      return 'openai';
-    case 'google':
-      return 'google';
-    case 'openrouter':
-      return 'openrouter';
+    case "anthropic":
+    case "bedrock":
+      return "claude";
+    case "openai":
+      return "openai";
+    case "google":
+      return "google";
+    case "openrouter":
+      return "openrouter";
   }
 }
 
@@ -542,20 +634,18 @@ function mapLlmProviderToDispatchProvider(provider: LlmProvider): ProviderName {
  * yet, so both pass no shell and those generations stay byte-identical — named
  * here rather than guessed.
  */
-function harnessShellForRendering(rendering: RenderingContext | undefined): 'chat' | undefined {
+function harnessShellForRendering(rendering: RenderingContext | undefined): "chat" | undefined {
   if (rendering === undefined) return undefined;
   switch (rendering.shell) {
-    case 'chat':
-      return 'chat';
-    case 'fullscreen':
-    case 'partial':
+    case "chat":
+      return "chat";
+    case "fullscreen":
+    case "partial":
       return undefined;
   }
 }
 
-function mapRendering(
-  rendering: UiGenerateInput['rendering'],
-): RenderingContext | undefined {
+function mapRendering(rendering: UiGenerateInput["rendering"]): RenderingContext | undefined {
   if (!rendering) return undefined;
   return {
     device: rendering.device,
@@ -568,7 +658,7 @@ function failWithoutMetadata(
   input: UiGenerateInput,
   generatorSlug: GeneratorId,
   startedAt: number,
-  error: GenerationError,
+  error: GenerationError
 ): UiGenerateResult {
   return {
     ok: false,
@@ -600,18 +690,18 @@ export function extractComponentCode(raw: string): string {
   const fences: Array<{ lang: string; body: string }> = [];
   let match: RegExpExecArray | null;
   while ((match = fencePattern.exec(raw)) !== null) {
-    const lang = (match[1] ?? '').toLowerCase();
-    const body = match[2] ?? '';
+    const lang = (match[1] ?? "").toLowerCase();
+    const body = match[2] ?? "";
     fences.push({ lang, body });
   }
 
   if (fences.length > 0) {
-    const priority = ['tsx', 'jsx', 'typescript', 'ts', 'javascript', 'js', ''];
+    const priority = ["tsx", "jsx", "typescript", "ts", "javascript", "js", ""];
     for (const preferred of priority) {
       const hit = fences.find((f) => f.lang === preferred);
       if (hit) return hit.body.trim();
     }
-    const firstBody = fences[0]?.body ?? '';
+    const firstBody = fences[0]?.body ?? "";
     return firstBody.trim();
   }
 

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,73 @@ 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: a `fail` verdict whose
+ * checks are `prop-sensitivity`, `action-wiring` or any other kind is
+ * recorded here and never fed back.
+ */
+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 +281,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