@ggui-ai/ui-gen 0.23.0 → 0.25.0

package/src/harness/coding/generate-task-runner.ts

@@ -12,7 +12,7 @@
 
 import type { Classification } from "../../classifier/index.js";
 import type { JsonValue } from "@ggui-ai/protocol";
-import type { ContractFeedbackRecord, EvalResult } from "../../evaluation/types-public.js";
+import type { ContractFeedbackRecord, EvalResult, RuntimeProbeMeta } from "../../evaluation/types-public.js";
 import type { Harness, Task, TaskContext } from "../types-public.js";
 import type { SingleComponentParams } from "../runtime.js";
 import type { TaskRunner } from "../index.js";
@@ -77,6 +77,16 @@ export interface GenerateTelemetry {
   cacheCreationTokens?: number;
   /** Latest evalResult — undefined when eval was disabled or never ran. */
   evalResult: EvalResult | undefined;
+  /**
+   * ggui#1380 — whether the probe-only lane's one repair turn has been
+   * spent. Set when the first probe-only round fed a recoverable render
+   * crash back; read by the next round (which then always breaks) and by
+   * the turn after the repair (which never loops on a failed self-check).
+   * Stays `false` on every other lane.
+   */
+  probeRepairUsed: boolean;
+  /** ggui#1380 C2b — the probe that bought the repair turn (the first probe-only round's meta), recorded on round 2 as `trigger`. */
+  probeRepairTrigger: RuntimeProbeMeta | undefined;
   /**
    * ggui#1261 — the contract-feedback round, once one fired: kept across the
    * rounds after it (each rebuilds `evalResult`) so the assembled result can
@@ -126,6 +136,8 @@ export function createTelemetry(): GenerateTelemetry {
     totalIn: 0,
     totalOut: 0,
     evalResult: undefined,
+    probeRepairUsed: false,
+    probeRepairTrigger: undefined,
     contractFeedback: undefined,
     sameExchangeBreak: undefined,
     compiledCode: "",
@@ -248,6 +260,8 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
           originalPrompt: params.userPrompt,
           commitMeta: session.commitMeta,
           originalProps: session.originalProps,
+          // ggui#1285: the fixture the probe and judge render with, for the echo check at auto-commit.
+          ...(params.fixtureProps !== undefined ? { fixtureProps: params.fixtureProps } : {}),
           costTracker: session.costTracker,
           // Thread the dispatch-resolved policy so experimental
           // profiles take effect on both preflight and tier-0 retry
@@ -274,6 +288,22 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
       iconNamesCache = turn.iconNamesCache;
       preWarmedContext = turn.preWarmedContext;
 
+      // ggui#1380 — the probe-only lane's repair turn did not produce a
+      // self-check-passing compile (a failed self-check, or no tool call):
+      // the lane grants AT MOST ONE eval-fix turn, so the loop never feeds
+      // the self-check violations back for another. The pre-repair card is
+      // what ships (`compiledCode` / `pairedSource` are untouched since the
+      // turn that compiled it), and the round's result records the repair
+      // as attempted but not compiled.
+      if (turn.control !== "proceed" && session.probeOnlyEnabled && telemetry.probeRepairUsed) {
+        if (telemetry.evalResult !== undefined) {
+          telemetry.evalResult = { ...telemetry.evalResult, runtimeProbeRepair: { attempted: true, compiled: false } };
+        }
+        console.log(
+          `[simple] probe-only repair turn did not compile (${turn.outcome ?? "no tool call"}) — serving the pre-repair card`,
+        );
+        break;
+      }
       if (turn.control === "break") break;
       if (turn.control === "continue") {
         lastResultText = turn.lastResultText;
@@ -326,11 +356,14 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
       }
 
       // ── Eval round ──
+      // Two lanes open the gate: the evaluation lane (its modules loaded, an
+      // evaluator configured) and the probe-only lane (ggui#1380: the probe
+      // wired, no evaluator — the round runs the probe once and nothing else).
       if (
         !evalDone &&
         telemetry.compiledCode &&
-        session.tiersMod &&
-        (session.codeEvalEnabled || session.visualEvalEnabled)
+        ((session.tiersMod && (session.codeEvalEnabled || session.visualEvalEnabled)) ||
+          session.probeOnlyEnabled)
       ) {
         // Measure eval-round wall-clock here (not inside runEvalRound) so the
         // accumulator covers axis-checks + LLM+visual parallel + merge +
@@ -348,14 +381,18 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
             evaluationAgent: session.agents.evaluation,
             visualEvalAgent: session.agents.visualEval,
             visualEvaluation: params.visualEvaluation,
+            shellType: params.shellType,
             visualThreshold: session.visualThreshold,
             qualityMode: session.qualityMode,
             maxEvalRounds: session.maxEvalRounds,
-            costTracker: session.costTracker!,
+            costTracker: session.costTracker,
             llmEvalMod: session.llmEvalMod,
             visualMod: session.visualMod,
             preWarmPromise: session.preWarmPromise,
             onProgress: params.onProgress,
+            probeOnly: session.probeOnlyEnabled,
+            probeRepairUsed: telemetry.probeRepairUsed,
+            ...(telemetry.probeRepairTrigger !== undefined ? { probeRepairTrigger: telemetry.probeRepairTrigger } : {}),
           },
           {
             compiledCode: telemetry.compiledCode,
@@ -379,6 +416,11 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
 
         if (round.control === "break") break;
         // round.control === "feedback" — set next coding turn input.
+        // On the probe-only lane this is the one repair turn (ggui#1380).
+        if (session.probeOnlyEnabled) {
+          telemetry.probeRepairUsed = true;
+          telemetry.probeRepairTrigger = round.evalResult?.runtimeProbe;
+        }
         lastResultText = round.lastResultText;
         isEvalFeedback = round.isEvalFeedback;
         lastDiffFailed = round.lastDiffFailed;
@@ -388,6 +430,20 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
       }
     } while (telemetry.turnsUsed < maxTurns && !evalDone);
 
+    // ggui#1380 — the probe-only lane's one repair turn was granted by the
+    // round but the turn cap had already been reached, so it was never taken:
+    // the card ships as it was, the probe's record stays, and no repair record
+    // is stamped (nothing was attempted). Say so, so the absence reads as the
+    // cap and not as a repair that vanished.
+    if (
+      session.probeOnlyEnabled &&
+      telemetry.probeRepairUsed &&
+      telemetry.evalResult !== undefined &&
+      telemetry.evalResult.runtimeProbeRepair === undefined
+    ) {
+      console.log(`[simple] probe-only repair turn not taken — turn cap (${maxTurns}) reached before it`);
+    }
+
     telemetry.codingMs = Date.now() - telemetry.codingStartedAtMs;
 
     // ── Fallback: pull compiled code from commitMeta if loop exited dry ──

package/src/harness/coding/init-session.ts

@@ -49,6 +49,16 @@ export interface CodingSession {
   // Eval gate config (computed once from params/qualityConfig).
   readonly codeEvalEnabled: boolean;
   readonly visualEvalEnabled: boolean;
+  /**
+   * ggui#1380 — the probe-only lane: the harness wires the runtime-render
+   * check and NO evaluator is configured (neither code nor visual). A
+   * serving deployment runs the probe once after the coding turns, observes,
+   * and buys one repair turn on a recoverable render crash. `evaluation:
+   * { enabled: false }` beside a wired probe is this lane too: a config
+   * that enables nothing is no evaluator. False whenever an evaluator runs —
+   * that lane's exit probe is a different round — and false without a probe.
+   */
+  readonly probeOnlyEnabled: boolean;
   readonly maxEvalRounds: number;
   readonly visualThreshold: number;
   readonly qualityMode: "fast" | "auto-improve" | "high-quality";
@@ -194,6 +204,8 @@ export async function initSession(input: {
   const qualityMode = qualityConfig?.quality ?? "fast";
   const codeEvalEnabled = !!params.evaluation?.enabled;
   const visualEvalEnabled = !!(params.visualEvaluation?.enabled || qualityConfig?.visualEval);
+  const probeOnlyEnabled =
+    harness.check.runtimeRender !== undefined && !codeEvalEnabled && !visualEvalEnabled;
   const maxEvalRounds =
     qualityMode === "high-quality"
       ? (params.evaluation?.maxRounds ?? 3)
@@ -230,6 +242,7 @@ export async function initSession(input: {
     systemPrompt,
     codeEvalEnabled,
     visualEvalEnabled,
+    probeOnlyEnabled,
     maxEvalRounds,
     visualThreshold,
     qualityMode,

package/src/harness/coding/run-coding-turn.ts

@@ -14,7 +14,7 @@
 // Behavior MUST match the inlined original byte-for-byte — this is a
 // mechanical extraction, not a redesign.
 
-import type { DataContract } from "@ggui-ai/protocol";
+import type { DataContract, JsonObject } from "@ggui-ai/protocol";
 import type { CommitMetadata } from "../../coding-agent/types.js";
 import type { AgentWorkspace } from "../../coding-agent/workspace.js";
 import { executeTool } from "../../coding-agent/tools.js";
@@ -30,9 +30,10 @@ import {
   APPLY_CHANGES_TOOL_SCOPED,
   GET_COMPONENTS_INFO_TOOL,
   GET_ICONS_TOOL,
+  ICON_LIST_NO_MATCH_GUIDANCE,
   REWRITE_TOOL,
-  WRITE_PLAN_TOOL,
   type LLMToolDef,
+  WRITE_PLAN_TOOL,
 } from "../../tools.js";
 import { LUCIDE_ICON_NAMES } from "@ggui-ai/design";
 import { formatWithHashlines } from "../hashline.js";
@@ -165,6 +166,8 @@ export interface CodingTurnContext {
   readonly originalPrompt: string;
   readonly commitMeta: Map<string, CommitMetadata>;
   readonly originalProps: string | undefined;
+  /** The props the probe and judge render with (ggui#1285) — handed to auto-commit's axis checks; absent = the echo check stands down. */
+  readonly fixtureProps?: JsonObject;
   readonly costTracker: CostTracker | null;
   /**
    * Runtime-resolved context policy. Defaults to `harness.policy.context`
@@ -614,7 +617,7 @@ ${closingInstruction}`;
       iconNamesCache = LUCIDE_ICON_NAMES.join(", ");
     }
     console.log(`[simple] turn ${turnsUsed}: get_available_icons`);
-    let iconResult = `Available Lucide icon names (use with <Icon name="...">):\n${iconNamesCache}`;
+    let iconResult = `Available Lucide icon names (use with <Icon name="...">):\n${iconNamesCache}\n\n${ICON_LIST_NO_MATCH_GUIDANCE}`;
     // ggui#404 same-call circuit breaker. The icon list is constant by
     // construction, so every repeat is an identical exchange — record on
     // the BASE text (pre-nudge) so the chain keys stay stable across the
@@ -690,6 +693,7 @@ ${closingInstruction}`;
       classification: harness.classification,
       originalPrompt: ctx.originalPrompt,
       ...(harness.canvas !== undefined ? { canvas: harness.canvas } : {}),
+      ...(ctx.fixtureProps !== undefined ? { fixtureProps: ctx.fixtureProps } : {}),
     },
   );
   const toolMs = Date.now() - toolStart;

package/src/harness/coding/run-eval-round.ts

@@ -10,24 +10,41 @@
 // (capped at MAX_FEEDBACK_ISSUES per turn).
 //
 // Does NOT own: the do/while wrapper, the eligibility gate at the call
-// site (`!evalDone && compiledCode && tiersMod && (codeEval || visualEval)`),
-// or the threading of mutable state — caller still owns those for now and
-// the closure migration (step 3) will move them too.
+// site (`!evalDone && compiledCode && ((tiersMod && (codeEval || visualEval))
+// || probeOnlyEnabled)` — the evaluation lane, or the probe-only lane a
+// serving deployment runs when it wires the runtime probe without an
+// evaluator, ggui#1380), or the threading of mutable state — caller still
+// owns those for now and the closure migration (step 3) will move them too.
 //
 // Behavior MUST match the inlined original byte-for-byte — this is a
 // mechanical extraction, not a redesign.
 
 import type { DataContract, JsonObject } from "@ggui-ai/protocol";
+import { criteriaContextFor } from "../../evaluation/criteria/context.js";
 import { listContractGadgets } from "@ggui-ai/protocol";
 import type { Classification } from "../../classifier/index.js";
 import type { AgentWorkspace } from "../../coding-agent/workspace.js";
 import type { CostTracker } from "../../evaluation/cost-tracker.js";
-import type { ContractFeedbackRecord, EvalIssue, EvalResult, RuntimeProbeMeta, VisualEvalSummary, VisualCoverage } from "../../evaluation/types-public.js";
+import type {
+  ContractFeedbackRecord,
+  EvalIssue,
+  EvalResult,
+  RuntimeProbeMeta,
+  RuntimeProbeMetaDetail,
+  RuntimeProbeRepair,
+  VisualEvalSummary,
+  VisualCoverage,
+} from "../../evaluation/types-public.js";
 import { notApplicableCoverage } from "../../evaluation/types-public.js";
 import { mapProviderForEvaluator, visionJudgeProvider } from "../enforced-coding.js";
 import { runCheck } from "../index.js";
-import { isRecoverableRenderCrash } from "../check/runtime-render/index.js";
-import type { Harness } from "../types-public.js";
+import {
+  RENDER_CHECK_KINDS,
+  isRecoverableRenderCrash,
+  parseRuntimeSubcategory,
+  type RenderCheckKind,
+} from "../check/runtime-render/index.js";
+import type { Harness, RuntimeRenderOutcome } from "../types-public.js";
 import type { AgentSpec, SingleComponentParams } from "../runtime.js";
 import type {
   CanvasFitReading,
@@ -58,15 +75,48 @@ export interface EvalRoundContext {
   readonly evaluationAgent: AgentSpec;
   readonly visualEvalAgent: AgentSpec;
   readonly visualEvaluation: SingleComponentParams["visualEvaluation"];
+  /** ggui#1436 — the shell as the caller named it, for the criteria selector's context; absent reads `unknown`. */
+  readonly shellType?: SingleComponentParams["shellType"];
   readonly visualThreshold: number;
   readonly qualityMode: "fast" | "auto-improve" | "high-quality";
   readonly maxEvalRounds: number;
-  /** Non-null inside a round — the call-site gate guarantees it's been built. */
-  readonly costTracker: CostTracker;
+  /**
+   * The evaluation lane's cost tracker. `null` on the probe-only lane, which
+   * runs no evaluator and records no cost; an evaluation round without one
+   * lands on the round's infra-skipped stamp (ggui#1110) with the reason
+   * {@link COST_TRACKER_ABSENT_REASON} — never a dereference.
+   */
+  readonly costTracker: CostTracker | null;
   readonly llmEvalMod: LlmEvalMod | null;
   readonly visualMod: VisualEvalMod | null;
   readonly preWarmPromise: Promise<PreWarmedEvalContext | null> | undefined;
   readonly onProgress?: (event: unknown) => void;
+  /**
+   * ggui#1380 — the probe-only lane: a serving deployment that wires the
+   * runtime probe and configures NO evaluator. The round runs the probe
+   * once and nothing else (no axis checks — the deterministic checks already
+   * ran in the coding turns' self-check — no evaluator, no visual leg).
+   * REQUIRED and explicit: it is never inferred from null modules, because the
+   * evaluation lane with null modules is a different round (the evaluation
+   * lane's own exit probe) and must stay one.
+   */
+  readonly probeOnly: boolean;
+  /**
+   * ggui#1380 — whether this generation already spent its one repair turn.
+   * `false` on the first probe-only round: a recoverable render crash there
+   * buys the turn. `true` on the second: the round breaks whatever the probe
+   * reads and records the repair with the probe that bought it as `trigger`.
+   * Meaningful on the probe-only lane only.
+   */
+  readonly probeRepairUsed: boolean;
+  /**
+   * ggui#1380 C2b — on the second probe-only round, the probe that bought the
+   * repair turn (the first round's meta), recorded as `runtimeProbeRepair.trigger`
+   * so the crash that happened is never lost behind the re-probe. The runner
+   * sets it together with `probeRepairUsed`; a re-probe round without it is a
+   * harness defect.
+   */
+  readonly probeRepairTrigger?: RuntimeProbeMeta;
 }
 
 /**
@@ -177,6 +227,29 @@ function formatFitFeedback(issue: EvalIssue): string {
 /** Why an eval result carries no criteria: the round itself threw (ggui#1110). */
 const EVAL_ROUND_THREW_REASON = "eval round threw";
 
+/**
+ * ggui#1380 — the coverage reasons a probe-only round stamps: no evaluator
+ * and no visual leg are configured, BY DESIGN, so every criterion is
+ * `not-applicable` (never `skipped`, which would read as a silent absence).
+ */
+const PROBE_ONLY_CRITERIA_REASON = "probe-only round: no evaluator configured";
+const PROBE_ONLY_VISUAL_REASON = "probe-only round: no visual evaluator configured";
+/** The `pass` entry a probe-only round records — the probe was the only gate. */
+const PROBE_ONLY_PASS = "probe-only";
+
+/**
+ * D3 (ggui#1380) — the evaluation lane's one named guard: a round that
+ * reaches the evaluator without a cost tracker cannot record what it spends,
+ * so it stops HERE, on the ggui#1110 infra-skipped stamp with this reason,
+ * instead of dereferencing `null` somewhere past the evaluator call.
+ */
+export const COST_TRACKER_ABSENT_REASON = "cost tracker absent on an evaluation round";
+
+function requireCostTracker(costTracker: CostTracker | null): CostTracker {
+  if (costTracker === null) throw new Error(COST_TRACKER_ABSENT_REASON);
+  return costTracker;
+}
+
 /**
  * The in-loop visual leg, made total (ggui#1248). The judge runs on a VISION
  * provider: the agent's provider narrowed by `visionJudgeProvider`, never
@@ -306,6 +379,62 @@ interface ProbeAtExitResult {
   readonly meta: RuntimeProbeMeta;
 }
 
+/**
+ * The distinct check kinds among a probe's `result: 'fail'` issues, in the
+ * order {@link RENDER_CHECK_KINDS} declares them (a render crash reads
+ * first). Parsed from the `runtime:<check>[:<subject>]` subcategory the
+ * adapter writes; a warn, an issue with no subcategory, or a subcategory that
+ * names no check contributes nothing.
+ */
+function failedCheckKinds(probeIssues: readonly EvalIssue[]): readonly RenderCheckKind[] {
+  const failed = new Set<RenderCheckKind>();
+  for (const issue of probeIssues) {
+    if (issue.result !== "fail" || issue.subcategory === undefined) continue;
+    const kind = parseRuntimeSubcategory(issue.subcategory);
+    if (kind !== undefined) failed.add(kind);
+  }
+  return RENDER_CHECK_KINDS.filter((kind) => failed.has(kind));
+}
+
+/**
+ * ONE builder for the meta every exit probe stamps (ggui#1380): the
+ * probe-only round and the evaluation lane's exit probe both go through
+ * `runProbeAtExit`, and this is where its outcome becomes a verdict. The
+ * verdict is computed from the PROBE'S OWN issues: `fail` when any check
+ * failed (`failChecks` = the distinct failing kinds), `pass` when none did;
+ * a probe that did not run to a verdict (`timed-out`, `infra-skipped`,
+ * `not-applicable`) carries no verdict key at all.
+ *
+ * The verdict is not the repair trigger. `fail` names ANY failing check;
+ * the one repair turn fires on a `render-no-throw` fail that
+ * `isRecoverableRenderCrash` recognises, and on nothing else — a `fail`
+ * verdict whose checks are `prop-sensitivity`, `action-wiring` or any other
+ * kind is recorded on the meta and never fed back.
+ */
+function probeMetaOf(outcome: RuntimeRenderOutcome, probeIssues: readonly EvalIssue[]): RuntimeProbeMeta {
+  const detail: RuntimeProbeMetaDetail = {
+    ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
+    ...(outcome.renderMs !== undefined ? { renderMs: outcome.renderMs } : {}),
+    ...(outcome.hostLoad !== undefined ? { hostLoad: outcome.hostLoad } : {}),
+    ...(outcome.queuedMs !== undefined ? { queuedMs: outcome.queuedMs } : {}),
+  };
+  const elapsed = outcome.elapsedMs !== undefined ? { elapsedMs: outcome.elapsedMs } : {};
+  if (outcome.status !== "ran") {
+    return { status: outcome.status, ...elapsed, ...detail };
+  }
+  const [first, ...rest] = failedCheckKinds(probeIssues);
+  if (first === undefined) {
+    return { status: "ran", verdict: "pass", ...elapsed, ...detail };
+  }
+  return { status: "ran", verdict: "fail", failChecks: [first, ...rest], ...elapsed, ...detail };
+}
+
+/** The probe's status and, when it ran, its verdict — for the round's log line. */
+function describeProbeMeta(meta: RuntimeProbeMeta): string {
+  if (meta.verdict === undefined) return meta.status;
+  return meta.verdict === "pass" ? "ran, verdict pass" : `ran, verdict fail (${meta.failChecks.join(", ")})`;
+}
+
 /**
  * Run the runtime-render probe ONCE at an exit-decision point. Off the
  * per-turn hot path: `runCheck` is invoked with `skipRuntimeRender: true`
@@ -356,12 +485,7 @@ async function runProbeAtExit(input: {
       meta: { status: "infra-skipped", reason: message },
     };
   }
-  const meta: RuntimeProbeMeta = {
-    status: outcome.status,
-    ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
-    ...(outcome.elapsedMs !== undefined ? { elapsedMs: outcome.elapsedMs } : {}),
-    ...(outcome.hostLoad !== undefined ? { hostLoad: outcome.hostLoad } : {}),
-  };
+  const meta = probeMetaOf(outcome, outcome.issues);
   if (outcome.status !== "ran") {
     return { fired: false, recoverableFail: false, probeIssues: [], meta };
   }
@@ -450,11 +574,13 @@ export async function runEvalRound(
     visualThreshold,
     qualityMode,
     maxEvalRounds,
-    costTracker,
     llmEvalMod,
     visualMod,
     preWarmPromise,
     onProgress,
+    probeOnly,
+    probeRepairUsed,
+    probeRepairTrigger,
   } = ctx;
   const { compiledCode, prevModeSubcats, prevFailFingerprints } = input;
   let { evalRoundsUsed, preWarmedContext } = input;
@@ -468,6 +594,102 @@ export async function runEvalRound(
   let evalLlmMs = 0;
 
   try {
+    // ── The probe-only round (ggui#1380) ──
+    // A serving deployment that wires the runtime probe and configures no
+    // evaluator: the probe runs ONCE, before anything else, and no axis
+    // check runs (the served card is the coding turns' — its deterministic
+    // checks ran in their self-check). A recoverable render crash on the
+    // first round buys exactly one repair turn; the second round breaks
+    // whatever it reads and records the repair's after. Timed-out,
+    // infra-skipped and not-applicable never block and never repair.
+    if (probeOnly) {
+      const exitProbe = await runProbeAtExit({
+        harness,
+        sourceCode: currentSource,
+        compiledCode,
+        contract,
+        fixtureProps,
+      });
+      const probeOnlyResult: EvalResult = {
+        issues: [...exitProbe.probeIssues],
+        pass: [PROBE_ONLY_PASS],
+        runtimeProbe: exitProbe.meta,
+        criteriaCoverage: notApplicableCoverage(PROBE_ONLY_CRITERIA_REASON),
+        visualCoverage: { status: "not-applicable", reason: PROBE_ONLY_VISUAL_REASON },
+      };
+      const recoverableFail = exitProbe.fired && exitProbe.recoverableFail;
+      if (probeRepairUsed) {
+        // This round IS the re-probe (a repair that did not compile never
+        // reaches a round — the runner stamps `compiled: false` itself). The
+        // top level is the re-probe; the record names the probe that bought
+        // the turn as `trigger`, so each probe is recorded exactly once.
+        if (probeRepairTrigger === undefined) {
+          throw new Error("harness defect: a probe-only re-probe round without the probe that bought the repair turn");
+        }
+        const repair: RuntimeProbeRepair = { attempted: true, compiled: true, trigger: probeRepairTrigger };
+        evalResult = { ...probeOnlyResult, runtimeProbeRepair: repair };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: probe-only re-probe after the repair turn — ` +
+            `${describeProbeMeta(exitProbe.meta)}${recoverableFail ? ", recoverable crash still present" : ""} — serving`,
+        );
+        return {
+          control: "break",
+          evalDone: true,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats,
+          prevFailFingerprints,
+          preWarmedContext,
+          evalTokens,
+          evalLlmMs,
+          lastResultText: "",
+          isEvalFeedback: false,
+          lastDiffFailed: false,
+        };
+      }
+      evalResult = probeOnlyResult;
+      if (recoverableFail) {
+        const runtimeFails = exitProbe.probeIssues.filter(
+          (i) => i.result === "fail" && i.subcategory?.startsWith("runtime:"),
+        );
+        const lines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: probe-only round — runtime probe fail (recoverable) — granting the one repair turn`,
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats,
+          prevFailFingerprints,
+          preWarmedContext,
+          evalTokens,
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+        };
+      }
+      console.log(
+        `[simple] eval round ${evalRoundsUsed}: probe-only round — probe ${describeProbeMeta(exitProbe.meta)} — serving`,
+      );
+      return {
+        control: "break",
+        evalDone: true,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats,
+        prevFailFingerprints,
+        preWarmedContext,
+        evalTokens,
+        evalLlmMs,
+        lastResultText: "",
+        isEvalFeedback: false,
+        lastDiffFailed: false,
+      };
+    }
+
     // Tier 0 already ran in autoCommit — go straight to mode-checks + LLM eval.
 
     // ── Axis-keyed deterministic checks ──────────────
@@ -582,6 +804,10 @@ export async function runEvalRound(
       };
     }
 
+    // D3 (ggui#1380) — the evaluation lane records what it spends; without a
+    // tracker it stops here, on the thrown-round stamp, with the reason.
+    const costTracker = requireCostTracker(ctx.costTracker);
+
     // Await pre-warmed context (only on first eval round, generated during coding)
     if (evalRoundsUsed === 1 && !preWarmedContext && preWarmPromise) {
       preWarmedContext = await preWarmPromise;
@@ -599,6 +825,22 @@ export async function runEvalRound(
       profile: harness.profile,
       // The caller's theme, when named — the round paints what the app paints.
       ...(visualEvaluation?.cssTokens !== undefined ? { cssTokens: visualEvaluation.cssTokens } : {}),
+      // ggui#1436 — the criteria bank and the card's context; the judge selects per canvas, report-only.
+      ...(visualEvaluation?.criteriaBank !== undefined
+        ? {
+            criteria: {
+              bank: visualEvaluation.criteriaBank,
+              context: criteriaContextFor({
+                classification,
+                contract,
+                cssTokens: visualEvaluation.cssTokens,
+                profile: harness.profile,
+                shell: ctx.shellType ?? "unknown",
+                ...(visualEvaluation.criteriaKind !== undefined ? { kind: visualEvaluation.criteriaKind } : {}),
+              }),
+            },
+          }
+        : {}),
     };
     const visualFrame: VisualFitConfig = {
       // The in-loop visual round renders the same sample the runtime probe

package/src/harness/policy.ts

@@ -252,6 +252,17 @@ export function resolveRunPolicyForProfile(
     };
   }
 
+  //   ctx-slice-primitives-v2 (ggui#1324) — the #45 slice plus the input
+  //   primitives the contract's slots and action payloads imply.
+  if (profile === "ctx-slice-primitives-v2") {
+    return {
+      context: {
+        ...harness.policy.context,
+        primitiveDocSlice: "axis-keyed+contract",
+      },
+    };
+  }
+
   // Archived experimental profiles:
   //
   //   experiment-40-provider-asymmetric — provider-specific tier-0 labels