@ggui-ai/ui-gen 0.22.0 → 0.24.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: "",
@@ -274,6 +286,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 +354,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 +
@@ -351,11 +382,14 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
             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 +413,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 +427,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-eval-round.ts

@@ -10,9 +10,11 @@
 // (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.
@@ -22,12 +24,26 @@ 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,
@@ -61,12 +77,43 @@ export interface EvalRoundContext {
   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 +224,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 +376,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,10 +482,7 @@ async function runProbeAtExit(input: {
       meta: { status: "infra-skipped", reason: message },
     };
   }
-  const meta: RuntimeProbeMeta = {
-    status: outcome.status,
-    ...(outcome.reason !== undefined ? { reason: outcome.reason } : {}),
-  };
+  const meta = probeMetaOf(outcome, outcome.issues);
   if (outcome.status !== "ran") {
     return { fired: false, recoverableFail: false, probeIssues: [], meta };
   }
@@ -448,11 +571,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;
@@ -466,6 +591,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 ──────────────
@@ -580,6 +801,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;

package/src/harness/llm-router.ts

@@ -875,8 +875,8 @@ export class AnthropicAgent extends LLMAgent {
           : toolChoice;
       if (appliedToolChoice !== toolChoice) {
         console.warn(
-          `[anthropic] callTools: ${normalizeAnthropicModelId(resolvedModel)} rejects forced tool_choice (HTTP 400); ` +
-            `caller's 'required' downgraded to 'auto'`,
+          `[anthropic] callTools: ${normalizeAnthropicModelId(resolvedModel)} would reject a forced tool_choice (the API answers 400); ` +
+            `caller's 'required' downgraded to 'auto' before sending`,
         );
       }
       const response = await this.apiCall(() =>
@@ -2128,7 +2128,7 @@ export class OpenRouterAgent extends LLMAgent {
       requested === 'required' && anthropicRejectsForcedToolChoice(resolved) ? 'auto' : requested;
     if (appliedToolChoice !== requested) {
       console.warn(
-        `[openrouter] callTools: ${resolved} rejects forced tool_choice (HTTP 400); caller's 'required' downgraded to 'auto'`,
+        `[openrouter] callTools: ${resolved} would reject a forced tool_choice (the API answers 400); caller's 'required' downgraded to 'auto' before sending`,
       );
     }
 

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

package/src/harness/primitive-slice.ts

@@ -23,6 +23,7 @@
 // prompt-build time and modifies the LLM's *initial* conditioning
 // uniformly — it cannot contaminate a retry trajectory mid-run.
 
+import type { DataContract, JsonSchema } from "@ggui-ai/protocol";
 import type { Classification } from "../classifier/index.js";
 
 /** Primitives every fixture needs — layout + typography + core interaction.
@@ -162,6 +163,62 @@ export function computePrimitiveAllowlist(
   return [...set].sort();
 }
 
+/**
+ * The input primitives a contract's own fields imply (ggui#1324).
+ *
+ * The axis-keyed allowlist is derived from the classification alone, so a card
+ * whose axes do not say "form" still loses the inputs its contract needs: the
+ * #45 kanban canary edits a task's title and priority through an action
+ * payload, and the axis slice dropped `Input` / `TextArea` / `Select`.
+ *
+ * Walks every context slot's schema and every action payload's schema down to
+ * its leaves (object `properties`, array `items`) and maps each leaf type:
+ * an `enum` → `Select`, `RadioGroup`; `string` → `Input`, `TextArea`,
+ * `FormField`; `number` / `integer` → `Input`, `Slider`; `boolean` →
+ * `Checkbox`, `Toggle`. A declared stream adds `Spinner` and `Badge`. Props are
+ * display data and add nothing (the classification covers display). Returns a
+ * sorted array.
+ */
+export function computeContractPrimitives(
+  contract: DataContract | undefined,
+): readonly string[] {
+  const out = new Set<string>();
+  if (!contract) return [];
+  for (const slot of Object.values(contract.contextSpec ?? {})) addLeaves(slot.schema, out);
+  for (const action of Object.values(contract.actionSpec ?? {})) {
+    if (action.schema) addLeaves(action.schema, out);
+  }
+  if (Object.keys(contract.streamSpec ?? {}).length > 0) {
+    out.add("Spinner");
+    out.add("Badge");
+  }
+  return [...out].sort();
+}
+
+function addLeaves(schema: JsonSchema, out: Set<string>): void {
+  for (const child of Object.values(schema.properties ?? {})) addLeaves(child, out);
+  if (schema.items) addLeaves(schema.items, out);
+  if (schema.enum && schema.enum.length > 0) {
+    out.add("Select");
+    out.add("RadioGroup");
+    return;
+  }
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  for (const t of types) {
+    if (t === "string") {
+      out.add("Input");
+      out.add("TextArea");
+      out.add("FormField");
+    } else if (t === "number" || t === "integer") {
+      out.add("Input");
+      out.add("Slider");
+    } else if (t === "boolean") {
+      out.add("Checkbox");
+      out.add("Toggle");
+    }
+  }
+}
+
 /**
  * Slice `PRIMITIVES_DOCUMENTATION` to include only the allowlisted primitive
  * sections. The doc structure is:
@@ -222,3 +279,50 @@ export function slicePrimitiveDocumentation(
 
   return preamble + kept.join("");
 }
+
+/**
+ * Slice the TypeScript-interface primitives reference
+ * (`PRIMITIVES_DOCUMENTATION_TS`) by the same allowlist the markdown
+ * slicer takes (ggui#1324, speed/002).
+ *
+ * The TS doc is a sequence of SECTIONS, each opened by a header line
+ * `// <Name> — <description>` and carrying that name's `interface`, its
+ * `// Example:` and the usage snippet that follows; category banners
+ * (`// ═══…`) sit between sections. A section whose `<Name>` is a KNOWN
+ * primitive is kept iff `<Name>` is in the allowlist. Every other line is
+ * kept: the preamble, the banners, the `CRITICAL` guidance sections, the
+ * support-type sections (`SelectOption`, `TableColumn`, …) and any section
+ * the slicer does not know — the same guidance rule as
+ * {@link slicePrimitiveDocumentation}. Allowing every known name returns the
+ * doc byte-identical.
+ *
+ * With no section header found the doc is returned whole (defensive, as the
+ * markdown slicer does when it finds no `### ` sections).
+ */
+export function slicePrimitiveDocumentationTs(
+  fullDoc: string,
+  allowlist: readonly string[],
+): string {
+  const allow = new Set(allowlist);
+  const lines = fullDoc.split("\n");
+  let sawHeader = false;
+  let keep = true;
+  const kept: string[] = [];
+  for (const line of lines) {
+    const header = TS_SECTION_HEADER.exec(line);
+    if (header !== null) {
+      sawHeader = true;
+      const name = header[1]!;
+      keep = !KNOWN_PRIMITIVE_SECTIONS.has(name) || allow.has(name);
+    } else if (TS_SECTION_BANNER.test(line)) {
+      keep = true;
+    }
+    if (keep) kept.push(line);
+  }
+  return sawHeader ? kept.join("\n") : fullDoc;
+}
+
+/** `// Button — A clickable button …`: the line that opens a TS-doc section. */
+const TS_SECTION_HEADER = /^\/\/ ([A-Za-z]+) — /;
+/** `// ═══…`: a category banner between TS-doc sections; always kept. */
+const TS_SECTION_BANNER = /^\/\/ ═/;