@ggui-ai/ui-gen 0.17.0 → 0.19.0

package/dist/workflows.d.ts

@@ -2,7 +2,7 @@ import { C as Classification } from './axes-CzLEMDeB.js';
 import { Workflow } from './harness/types-public.js';
 import '@ggui-ai/protocol';
 import './styling-profile-CxfvV48g.js';
-import './types-public-DVSssdc-.js';
+import './types-public-DKR_h70H.js';
 import './design-mode-DLufhrNp.js';
 import './types-BOvHNG7K.js';
 import './llm.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/ui-gen",
-  "version": "0.17.0",
+  "version": "0.19.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": [
@@ -188,9 +188,9 @@
     "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.17.0",
-    "@ggui-ai/protocol": "0.17.0",
-    "@ggui-ai/project-config": "0.17.0"
+    "@ggui-ai/mcp-server-core": "0.19.0",
+    "@ggui-ai/project-config": "0.19.0",
+    "@ggui-ai/protocol": "0.19.0"
   },
   "peerDependenciesMeta": {
     "@google/adk": {
@@ -229,11 +229,11 @@
     "openai": "^7.9.0",
     "typescript": "^5.0.0",
     "zod": "^4.3.6",
-    "@ggui-ai/sandbox": "0.17.0",
-    "@ggui-ai/gadgets": "0.17.0",
-    "@ggui-ai/design": "0.17.0",
-    "@ggui-ai/wire": "0.17.0",
-    "@ggui-ai/ui-visual-tester": "0.17.0"
+    "@ggui-ai/design": "0.19.0",
+    "@ggui-ai/gadgets": "0.19.0",
+    "@ggui-ai/sandbox": "0.19.0",
+    "@ggui-ai/wire": "0.19.0",
+    "@ggui-ai/ui-visual-tester": "0.19.0"
   },
   "devDependencies": {
     "@google/adk": "^2.0.0",
@@ -248,9 +248,9 @@
     "react-dom": "^19.0.0",
     "tsup": "^8.5.0",
     "vitest": "^3.2.6",
-    "@ggui-ai/project-config": "0.17.0",
-    "@ggui-ai/mcp-server-core": "0.17.0",
-    "@ggui-ai/protocol": "0.17.0"
+    "@ggui-ai/mcp-server-core": "0.19.0",
+    "@ggui-ai/project-config": "0.19.0",
+    "@ggui-ai/protocol": "0.19.0"
   },
   "engines": {
     "node": ">=22.0.0"

package/src/adapters/google/sdk.ts

@@ -62,15 +62,10 @@ export async function runAdkLoop(
 ): Promise<AdapterResult> {
   const startTime = Date.now();
 
-  const { FunctionTool, LlmAgent, InMemoryRunner, isFinalResponse } = await import('@google/adk');
+  const { FunctionTool, Gemini, LlmAgent, InMemoryRunner, isFinalResponse } = await import('@google/adk');
 
   const capture = createCapture();
 
-  // Ensure ADK can find the API key
-  if (params.apiKey && !process.env.GOOGLE_GENAI_API_KEY) {
-    process.env.GOOGLE_GENAI_API_KEY = params.apiKey;
-  }
-
   // Build tools with capture wrappers
   const adkTools = params.tools.map((def) =>
     new FunctionTool({
@@ -88,9 +83,18 @@ export async function runAdkLoop(
     }),
   );
 
+  // The key the caller passed WINS, handed to the model directly (ggui#1132).
+  // The ADK resolves GOOGLE_GENAI_API_KEY || GOOGLE_API_KEY || GEMINI_API_KEY
+  // on its own when no key is given, so writing GOOGLE_GENAI_API_KEY here —
+  // a variable this adapter does not own — let a stale ambient value beat a
+  // fresh key, and no rotation could reach it. Precedence is fixed at the
+  // source: an explicit key never touches process.env; no key defers to the
+  // ADK's order untouched.
+  const model = params.apiKey ? new Gemini({ model: params.model, apiKey: params.apiKey }) : params.model;
+
   const agent = new LlmAgent({
     name: 'ui_generator',
-    model: params.model,
+    model,
     instruction: params.systemPrompt,
     tools: adkTools,
   });

package/src/boilerplate/free-design-prompt.ts

@@ -29,6 +29,7 @@ import {
   DATA_PARAMETERIZATION,
   DEFENSIVE_CODING,
   FRAME_SIZING,
+  TERMINAL_ACTIONS,
   GESTURE_ROUTING,
   PROTOCOL_NOTES,
   renderGadgetCatalogSection,
@@ -310,6 +311,7 @@ ${axisSection}
     CONTRACT_SURFACE,
     DEFENSIVE_CODING,
     GESTURE_ROUTING,
+    TERMINAL_ACTIONS,
     FREE_GESTURE_SURFACE,
     ANTI_PATTERNS,
     CROSS_REFERENCE_RULES,

package/src/boilerplate/generate.ts

@@ -252,7 +252,14 @@ export function generateBoilerplate(
     // Inline signature tells the LLM exactly how to call this action
     const callSig = tsType === "void" ? "() => void — fire and forget" : `(data: ${tsType}) => void`;
     const toolHint = tool ? ` → nextStep: ${tool}` : "";
-    actionHookCalls.push(`  const ${key} = useAction<${typeName}>('${key}'); // ${callSig}${toolHint}`);
+    // ggui#1108 (mitigation): the reminder sits at the EXACT site the model
+    // writes the handler. It is a hint, not the rule — the rule is the prompt's
+    // `TERMINAL_ACTIONS` section, because only the request and the contract say
+    // which actions are meant once. A site comment alone moves generation by
+    // roughly nothing (Exp 002b: adoption 1/36), which is why it is the
+    // smallest of the three legs and never the one relied on.
+    const onceHint = " — if this is meant ONCE, disable its control after it fires";
+    actionHookCalls.push(`  const ${key} = useAction<${typeName}>('${key}'); // ${callSig}${toolHint}${onceHint}`);
     actionReturnFields.push(key);
   }
 

package/src/boilerplate/hard-sections.ts

@@ -213,9 +213,31 @@ Rules:
 1. All request-specific data → props with defaults. City names, tickers, user names, dates, counts.
 2. Layout and styling are universal. Colors, spacing, structure — these are the reusable part.
 3. Default values come from the current request — so the component renders correctly standalone.
-4. Copy comes from the props. NEVER invent display text the contract does not carry — no eyebrow / kicker / overline (a \`<Text caps>\` label), no helper line, no status text, no tagline. A caps label exists only when a prop supplies its text (\`<Text caps>{props.section}</Text>\`); a heading's fallback is the request's own words, never a slogan of your own. Text the agent cannot change is chatter on every render.
+4. Copy comes from the props. NEVER invent display text the contract does not carry — no eyebrow / kicker / overline (a \`<Text caps>\` label), no helper line, no status text, no tagline. **Do NOT add a caps label above the heading** — not \`<Text caps>LET'S BEGIN</Text>\`, not \`WELCOME\`, not a section kicker like \`GETTING STARTED\` or \`OVERVIEW\` — UNLESS a prop supplies that exact text (\`<Text caps>{props.section}</Text>\`). When the request asks for a heading and a line, render the heading and the line and NOTHING above the heading. A heading's fallback is the request's own words, never a slogan of your own. Text the agent cannot change is chatter on every render, and a caps eyebrow you wrote is the most common form of it.
 5. Props interface must be typed and exported.`;
 
+/**
+ * A control that fires an action the user would not mean to repeat must not
+ * stay armed (ggui#1108 MITIGATION — the fix is one-shot-ness DECLARED on the
+ * action and enforced by the runtime; this reduces exposure meanwhile). Both
+ * arms, one HARD section: the model knows from the request and the contract
+ * which actions are terminal, which no static rule of ours can infer.
+ */
+export const TERMINAL_ACTIONS = `## Actions the user means once
+
+A second press is a mistake only when it would make a SECOND THING HAPPEN IN THE WORLD — a second booking, a second charge, a second order, a second application sent. If pressing again would only write the SAME STATE AGAIN — saving, updating, renaming, setting a preference, toggling — nothing is duplicated and the control stays armed.
+
+Guard a control only where you have evidence, not a feeling about the verb: the request itself names a one-time commitment — "submit the application", "place the order", "confirm the booking".
+
+**When in doubt, leave it armed.** A control the user cannot press a second time has lost them something that worked — save, edit, save again is ordinary. A control left armed is only what every interface does by default.
+
+When you do guard one:
+- Hold a small piece of state for it and set it in the handler: \`const [submitted, setSubmitted] = useState(false)\`.
+- \`disabled={submitted}\` on the control that fires it, and say so in the label or beside it ("Submitted", "Request sent") — a control that is disabled without explanation reads as broken.
+- A card re-rendered with new props starts fresh; the state above lives with the component, not with the request.
+
+Nothing in the wire DECLARES one-shot-ness yet, which is why the test is what a second press would DO — not how final the word sounds.`;
+
 /**
  * The frame owns the height — the component never sizes itself to the
  * viewport (ggui#1075 Track A/B; receipted on #1096: 20 of 48 minted cells
@@ -223,12 +245,19 @@ Rules:
  * card told "compact"). Identical in both modes; the eval leg's tier-0
  * `universal.viewport_sized` fails what slips through.
  */
-export const FRAME_SIZING = `## Sizing — the frame owns the height
+export const FRAME_SIZING = `## Sizing — the frame owns the height and the width
 
 The host sizes the iframe; the component never sizes itself to the viewport. NEVER write \`100vh\` / \`100dvh\` / \`100svh\` (or an \`h-screen\` / \`min-h-screen\` class) as a height on any element:
 - An inline card takes its natural height. A content-sized frame is measured FROM the content, so a \`100vh\` root can never shrink and grows the frame on every re-measure.
 - Under fullscreen the frame already stretches your root to its full height. Centre inside it with flex (\`display: flex; flex-direction: column; justify-content: center\`), never with a viewport height.
-- To fill a parent that has a height use \`height: 100%\` or \`flex: 1\`; a viewport unit is only ever a \`max-height\` cap on a scroll region.`;
+- To fill a parent that has a height use \`height: 100%\` or \`flex: 1\`; a viewport unit is only ever a \`max-height\` cap on a scroll region.
+
+The width works the same way, and the mistake is the mirror image: **your outermost element FILLS the frame; a width cap belongs INSIDE it, on the column that holds text.**
+
+- Never put \`maxWidth\` (or a \`max-w-*\` class) on the element you return at the top. On a wide canvas that turns your card into a narrow strip with the frame's ground on either side of it, and on a narrow one it does nothing — the same composition reading differently at two sizes.
+- DO cap the reading measure inside: a column of prose is easiest to read at 60–70 characters, so wrap the TEXT in a \`<Container maxWidth="sm">\` (or your own \`max-width\`) and leave the root filling. A hero band, a toolbar, a table or an image then still uses the whole width, which is what makes a wide card look composed rather than padded.
+- Centre that inner column with the container's own centring, not by shrinking the root.
+- **They are two different elements.** Even when the whole card is one column of text, the root still fills and the column sits INSIDE it — \`<Box padding="lg"><Container maxWidth="sm">…</Container></Box>\`, never a root that is itself the container. A centred card is centring inside a filled frame, not a shrunken frame.`;
 
 /** Helper-component structure guidance (JSX depth 3–5, helpers above `Component`). Identical in both modes. */
 export const COMPONENT_STRUCTURE = `## Component Structure

package/src/boilerplate/system-prompt.ts

@@ -41,6 +41,7 @@ import {
   DEFENSIVE_CODING,
   FRAME_SIZING,
   GESTURE_ROUTING,
+  TERMINAL_ACTIONS,
   INTERACTIVE_TRAITS,
   PROTOCOL_NOTES,
   renderGadgetCatalogSection,
@@ -383,6 +384,7 @@ ${axisSection}
       CONTRACT_SURFACE,
       DEFENSIVE_CODING,
       GESTURE_ROUTING,
+      TERMINAL_ACTIONS,
       INTERACTIVE_TRAITS,
       ANTI_PATTERNS,
       CROSS_REFERENCE_RULES,
@@ -601,7 +603,7 @@ Don't render text-only metrics. A weather widget without a sun/cloud, a stock ca
 </Row>
 \`\`\`
 
-Use \`<Icon name="..." />\` for line icons — ONLY the curated Lucide subset renders (call \`get_available_icons\` for the exact kebab-case names; a name outside it renders an empty box and fails the check); emoji directly for status/weather/mood. Both are valid. For per-stat tiny accents, use a small icon next to the label.
+Use \`<Icon name="..." />\` for line icons — ONLY the design system's curated set renders (~200 kebab-case Lucide names); a name OUTSIDE it renders an empty box and fails the check. On a single-pass render you cannot look the set up, so use ONLY a name you are sure is in it. Safe common names: \`check\` \`x\` \`plus\` \`minus\` \`search\` \`settings\` \`user\` \`users\` \`calendar\` \`clock\` \`arrow-right\` \`arrow-left\` \`chevron-right\` \`chevron-down\` \`trash-2\` \`edit\` \`info\` \`alert-circle\` \`bell\` \`home\` \`file\` \`file-text\` \`star\` \`heart\` \`mail\` \`send\` \`download\` \`upload\` \`external-link\` \`filter\` \`check-circle\`. The numbered variants (\`edit-2\`, \`edit-3\`) and synonyms (\`pencil\`, \`pen\`, \`trash\`, \`x-circle\`) are NOT in the set — use \`edit\` and \`trash-2\`. If the icon you want is not clearly one of these, OMIT it: a card with no icon beats one with an empty box. Emoji render directly for status/weather/mood. For per-stat tiny accents, use a small icon next to the label.
 
 ### Spacing — generosity beats compactness
 

package/src/boilerplate/templates/layouts/fullscreen-desktop.tsx.tmpl

@@ -1,3 +1,5 @@
-    <Container maxWidth="xl" padding="lg">
-      {/* implement your UI here */}
-    </Container>
+    <Box padding="lg">
+      {/* implement your UI here — this root FILLS the frame.
+          Bands, toolbars, tables and images use the whole width;
+          wrap PROSE in <Container maxWidth="sm"> to cap the reading measure. */}
+    </Box>

package/src/boilerplate/templates/layouts/fullscreen-mobile.tsx.tmpl

@@ -1,3 +1,3 @@
-    <Container maxWidth="sm" padding="md">
-      {/* implement your UI here */}
-    </Container>
+    <Box padding="md">
+      {/* implement your UI here — this root FILLS the frame (a phone IS the measure). */}
+    </Box>

package/src/boilerplate/templates/layouts/fullscreen-universal.tsx.tmpl

@@ -1,3 +1,5 @@
-    <Container maxWidth="xl" padding="lg">
-      {/* implement your UI here */}
-    </Container>
+    <Box padding="lg">
+      {/* implement your UI here — this root FILLS the frame.
+          Bands, toolbars, tables and images use the whole width;
+          wrap PROSE in <Container maxWidth="sm"> to cap the reading measure. */}
+    </Box>

package/src/check/run-tier0.ts

@@ -352,6 +352,137 @@ function isGadgetExportImported(
   return false;
 }
 
+/**
+ * AST-precise detector for the compiles-but-renders-nothing class: the
+ * default-exported component's body never returns a tree.
+ *
+ * The boilerplate HANDS the model the wrapper — `base.tsx.tmpl` and
+ * `base-free.tsx.tmpl` both emit `return (` … `);` around `{{LAYOUT}}`.
+ * A model rewriting the root block can delete those two lines with it,
+ * leaving the JSX as a bare expression statement. That is legal TSX: it
+ * parses, esbuild compiles it, `typecheck()` passes it, and the
+ * component renders a blank frame. Seen once in twenty takes of the
+ * ggui#1113 A/B (`xs-chat-card`, run 2 — the judge spent a screenshot
+ * and an LLM call to report "completely blank").
+ *
+ * `compile/default-export` already guards the scaffold's
+ * `export default function` line and `types/props-interface` its
+ * `interface Props` line. The `return (` was the third scaffold line
+ * with nothing watching it.
+ *
+ * Conservative by construction — it reports ONLY when it positively
+ * identified a block-bodied default-export component:
+ *   - a concise arrow body (`export default () => <X/>`) returns by
+ *     construction → silent
+ *   - `export default memo(Component)` or any other expression it
+ *     cannot resolve to a function → silent
+ *   - a `return` inside a nested helper is not the component's own (the
+ *     walk stops at every nested function boundary), but ONE own-level
+ *     `return <value>` anywhere — an early `return null` included —
+ *     satisfies it.
+ *
+ * Returns `null` when the component returns (or could not be
+ * identified), else the 1-based line of the first bare JSX expression
+ * statement in its body — the line the fix belongs on — or `undefined`
+ * when the body has no JSX statement to point at either.
+ */
+function detectComponentNeverReturns(
+  sourceCode: string,
+): { jsxStatementLine: number | undefined } | null {
+  const sf = ts.createSourceFile(
+    'source.tsx',
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */ true,
+    ts.ScriptKind.TSX,
+  );
+
+  const isFunctionLike = (n: ts.Node): boolean =>
+    ts.isFunctionDeclaration(n) ||
+    ts.isFunctionExpression(n) ||
+    ts.isArrowFunction(n) ||
+    ts.isMethodDeclaration(n) ||
+    ts.isClassDeclaration(n) ||
+    ts.isClassExpression(n);
+
+  /** The top-level declaration `name` binds to, when it is a function. */
+  function resolveTopLevel(
+    name: string,
+  ): ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | undefined {
+    for (const st of sf.statements) {
+      if (ts.isFunctionDeclaration(st) && st.name?.text === name) return st;
+      if (ts.isVariableStatement(st)) {
+        for (const decl of st.declarationList.declarations) {
+          if (
+            ts.isIdentifier(decl.name) &&
+            decl.name.text === name &&
+            decl.initializer !== undefined &&
+            (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))
+          ) {
+            return decl.initializer;
+          }
+        }
+      }
+    }
+    return undefined;
+  }
+
+  let component:
+    | ts.FunctionDeclaration
+    | ts.FunctionExpression
+    | ts.ArrowFunction
+    | undefined;
+  for (const st of sf.statements) {
+    if (
+      ts.isFunctionDeclaration(st) &&
+      st.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)
+    ) {
+      component = st;
+      break;
+    }
+    if (ts.isExportAssignment(st) && st.isExportEquals !== true) {
+      const expr = st.expression;
+      if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) component = expr;
+      else if (ts.isIdentifier(expr)) component = resolveTopLevel(expr.text);
+      break;
+    }
+  }
+  // No default export at all, or one this detector cannot resolve to a
+  // function — `compile/default-export` owns the first case and the
+  // second is not ours to guess at.
+  if (component === undefined) return null;
+
+  const body = component.body;
+  // A concise arrow body IS the returned value.
+  if (body === undefined || !ts.isBlock(body)) return null;
+
+  let returnsValue = false;
+  let jsxStatementLine: number | undefined;
+  const visit = (node: ts.Node): void => {
+    if (returnsValue) return;
+    if (ts.isReturnStatement(node)) {
+      if (node.expression !== undefined) returnsValue = true;
+      return;
+    }
+    if (
+      jsxStatementLine === undefined &&
+      ts.isExpressionStatement(node) &&
+      (ts.isJsxElement(node.expression) ||
+        ts.isJsxFragment(node.expression) ||
+        ts.isJsxSelfClosingElement(node.expression))
+    ) {
+      jsxStatementLine = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+    }
+    node.forEachChild((child) => {
+      // A helper component's own `return` is not this component's.
+      if (!isFunctionLike(child)) visit(child);
+    });
+  };
+  for (const st of body.statements) if (!isFunctionLike(st)) visit(st);
+
+  return returnsValue ? null : { jsxStatementLine };
+}
+
 /**
  * Run all tier 0 (deterministic, no-LLM) checks against component source.
  *
@@ -982,6 +1113,27 @@ export async function runTier0Checks(
     });
   }
 
+  // ── Component never returns its tree ──────────────────────
+  // The scaffold hands the model `return (` … `);` around the layout.
+  // A root-block rewrite can delete them with it, and bare JSX at
+  // statement position compiles, type-checks and renders NOTHING.
+  const neverReturns = detectComponentNeverReturns(sourceCode);
+  if (neverReturns !== null) {
+    issues.push({
+      tier: 0,
+      result: 'fail',
+      category: 'compile',
+      subcategory: 'renders-nothing',
+      severity: 'critical',
+      description:
+        neverReturns.jsxStatementLine === undefined
+          ? 'The component never returns its tree — it renders a blank frame'
+          : `The component never returns its tree: the JSX at line ${neverReturns.jsxStatementLine} sits at statement position, so it is built and thrown away and the frame renders blank`,
+      fix: 'Wrap the tree in the return the boilerplate gave you: `return (` before the root element and `);` after it.',
+      ...(neverReturns.jsxStatementLine === undefined ? {} : { line: neverReturns.jsxStatementLine }),
+    });
+  }
+
   // (Controller-View checks removed — generated components use a
   // single-function pattern.)
 

package/src/coding-agent/tools.ts

@@ -12,6 +12,10 @@ import * as esbuild from 'esbuild';
 import { AgentWorkspace } from './workspace';
 import { getSoftWarnings } from './self-check';
 import { runTier0Checks } from '../check/index.js';
+import { runGatedAxisChecks, traceAxisChecksSkipped } from '../evaluation/axis-checks/dispatch.js';
+import type { AxisCheck, AxisCheckInput } from '../evaluation/types-public.js';
+import type { Classification } from '../classifier/axes.js';
+import type { CanvasClass } from '../design-mode.js';
 import { PRIMITIVES_DOCUMENTATION } from '../validation/index.js';
 import type { DataContract } from '@ggui-ai/protocol';
 import type {
@@ -46,6 +50,22 @@ function getComponentDocumentation(name: string): string {
 // Auto-commit helper (shared by write and apply_changes)
 // =============================================================================
 
+/**
+ * The deterministic axis family at auto-commit (ggui#1122) — what a caller with a
+ * harness hands `executeTool` so the checks run on EVERY commit the coding agent
+ * makes, i.e. on the serve path, not only inside the eval round a serving deployment
+ * never enters. `checks` is the harness's pre-filtered list (`harness.check.axisChecks`)
+ * — the same list `run-check.ts` feeds the same pure runner. Absent: nothing runs.
+ */
+export interface AutoCommitAxisChecks {
+  readonly checks: readonly AxisCheck[];
+  readonly classification: Classification;
+  /** The ORIGINAL request — several checks read it (labels invented past the copy, terminal words). */
+  readonly originalPrompt: string;
+  /** The canvas the harness was built for (ggui#1117); absent = no rendering context, never a default. */
+  readonly canvas?: CanvasClass;
+}
+
 async function autoCommit(
   workspace: AgentWorkspace,
   commitMeta: Map<string, CommitMetadata>,
@@ -72,6 +92,8 @@ async function autoCommit(
   gadgetTypes?: Readonly<Record<string, string>>,
   /** Which tier-0 legs fire — see `runTier0Checks`'s `designMode`. */
   designMode: DesignMode = DEFAULT_DESIGN_MODE,
+  /** ggui#1122: run the harness's axis checks here too; absent, none run. */
+  axis?: AutoCommitAxisChecks,
 ): Promise<ToolResult> {
   const commitStart = Date.now();
   const raw = workspace.read();
@@ -123,17 +145,45 @@ async function autoCommit(
     gadgetTypes,
     designMode,
   );
-  const tier0Fails = tier0Issues.filter(i => i.result === 'fail');
+  // ggui#1122: the deterministic axis family runs HERE — on every commit the coding
+  // agent makes, which is the serve path — through the one pure runner `run-check.ts`
+  // feeds (the ggui#1046 trace line prints on both paths). Posture is the founder's:
+  // warn-as-warn, fail-as-fail. A WARN that started blocking a served generation
+  // because it moved surface would be a posture change, not a relocation, and comes
+  // to him as a named item. Only a source that BUILT is judged: on a build failure
+  // the checks are not asked (the same stand-down the gate+run wrapper makes) and
+  // the ggui#1046 trace says so — a skipped round never reads as a clean one.
+  const axisFacts = axis !== undefined
+    ? {
+        sourceCode: formatted,
+        ...(contract !== undefined ? { contract } : {}),
+        originalPrompt: axis.originalPrompt,
+        classification: axis.classification,
+        designMode,
+        ...(axis.canvas !== undefined ? { canvas: axis.canvas } : {}),
+      }
+    : undefined;
+  if (axisFacts !== undefined && !buildSuccess) traceAxisChecksSkipped(axisFacts, 'build failed — no check ran');
+  const axisRun = axis !== undefined && axisFacts !== undefined && buildSuccess
+    ? runGatedAxisChecks(axis.checks, { ...axisFacts, compiledCode } satisfies AxisCheckInput)
+    : undefined;
+  const axisIssues = axisRun?.issues ?? [];
+  const checkIssues = [...tier0Issues, ...axisIssues];
+  const tier0Fails = checkIssues.filter(i => i.result === 'fail');
   const selfCheckPassed = tier0Fails.length === 0;
   // When contextPolicy.labeledTier0 is set, prefix each violation with
   // its P0/P1/P2 priority so the LLM can rank against the prompt's
   // schema. The default (off) emits unlabeled feedback.
-  const violations = tier0Issues
+  const violations = checkIssues
     .filter(i => i.result === 'fail')
     .map(i => contextPolicy?.labeledTier0
       ? `[${i.priority ?? 'P0'}-${i.category}] ${i.description}\n  Fix: ${i.fix}`
       : `[${i.category}] ${i.description}\n  Fix: ${i.fix}`);
-  const softWarnings = getSoftWarnings(raw);
+  // Axis WARNs ride the existing non-blocking channel — feedback the model sees, never a block.
+  const axisWarnings = axisIssues
+    .filter(i => i.result === 'warn')
+    .map(i => `[${i.subcategory}] ${i.description} Fix: ${i.fix}`);
+  const softWarnings = [...getSoftWarnings(raw), ...axisWarnings];
   const selfCheckMs = Date.now() - selfCheckStart;
 
   // Always commit (preserves history)
@@ -144,7 +194,7 @@ async function autoCommit(
 
   const status = buildSuccess && selfCheckPassed ? 'PASS' : 'FAIL';
   console.log(
-    `[coding-agent] auto-commit: ${status} | build=${buildMs}ms self-check=${selfCheckMs}ms git=${gitMs}ms total=${Date.now() - commitStart}ms | violations=${violations.length}`,
+    `[coding-agent] auto-commit: ${status} | build=${buildMs}ms self-check=${selfCheckMs}ms git=${gitMs}ms total=${Date.now() - commitStart}ms | violations=${violations.length} | axis=${axisRun === undefined ? 'off' : `${axisIssues.length - axisWarnings.length}F/${axisWarnings.length}W`}`,
   );
   if (violations.length > 0) {
     for (const v of violations) {
@@ -202,6 +252,8 @@ export async function executeTool(
   gadgetTypes?: Readonly<Record<string, string>>,
   /** Which tier-0 legs fire on auto-commit — see `runTier0Checks`'s `designMode`. */
   designMode: DesignMode = DEFAULT_DESIGN_MODE,
+  /** ggui#1122: the harness's axis checks, run at every auto-commit — see `AutoCommitAxisChecks`. */
+  axis?: AutoCommitAxisChecks,
 ): Promise<ToolResult> {
   switch (tool) {
     case 'write':
@@ -222,7 +274,7 @@ export async function executeTool(
       const message = (input.commit_message as string) || `write ${lineCount} lines`;
 
       console.log(`[coding-agent] write: ${lineCount} lines → auto-commit`);
-      return autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode);
+      return autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode, axis);
     }
 
     case 'apply_changes': {
@@ -529,7 +581,7 @@ export async function executeTool(
       const message = (input.commit_message as string) || 'apply changes';
 
       console.log(`[coding-agent] apply_changes: ${changes.length} changes applied → auto-commit`);
-      return autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode);
+      return autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode, axis);
     }
 
     case 'get_components_info': {

package/src/contract-context.ts

@@ -202,6 +202,19 @@ export function buildContractsContext(
         if (entry.nextStep) {
           line += `\n    Next-step hint: agent intends to call \`${entry.nextStep}\``;
         }
+        // ggui#1108: `confirm` was the one declared action field the contract
+        // renderer dropped — every other author field (label, description,
+        // example, nextStep) reaches the model and this one did not. It is
+        // rendered as INFORMATION, not as a rule: the terminal-actions section
+        // deliberately does NOT cite it, because citing it measured ZERO —
+        // two wordings, n=4 each, `save` + `confirm: true` came back armed 0/4
+        // and 0/4. The field's own doc says "whether to show confirmation
+        // BEFORE triggering", which is gravity, not one-shot-ness, and the
+        // model reads it that way. Emitted only when true, so an absent flag
+        // leaves the prompt bytes identical to before this line existed.
+        if (entry.confirm === true) {
+          line += `\n    Author flag: \`confirm\` — the author marked this action as one to confirm with the user before it fires.`;
+        }
         return line;
       })
       .join('\n');

package/src/create-harness.ts

@@ -224,6 +224,7 @@ export function createHarness(input: CreateHarnessInput): Harness {
     name,
     classification,
     designMode,
+    ...(input.canvas !== undefined ? { canvas: input.canvas } : {}),
     ...(input.profile !== undefined ? { profile: input.profile } : {}),
     how,
     what,