@ggui-ai/ui-gen 0.19.0 → 0.21.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-DKR_h70H.js';
+import './types-public-CzYqZclY.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.19.0",
+  "version": "0.21.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": [
@@ -185,12 +185,13 @@
   "peerDependencies": {
     "@google/adk": "^2.0.0",
     "@openai/agents": "^0.17.0",
+    "@sparticuz/chromium": "^149.0.0",
     "puppeteer-core": "^24.40.0 || ^25.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@ggui-ai/mcp-server-core": "0.19.0",
-    "@ggui-ai/project-config": "0.19.0",
-    "@ggui-ai/protocol": "0.19.0"
+    "@ggui-ai/protocol": "0.21.0",
+    "@ggui-ai/mcp-server-core": "0.21.0",
+    "@ggui-ai/project-config": "0.21.0"
   },
   "peerDependenciesMeta": {
     "@google/adk": {
@@ -199,6 +200,9 @@
     "@openai/agents": {
       "optional": true
     },
+    "@sparticuz/chromium": {
+      "optional": true
+    },
     "puppeteer-core": {
       "optional": true
     },
@@ -229,11 +233,11 @@
     "openai": "^7.9.0",
     "typescript": "^5.0.0",
     "zod": "^4.3.6",
-    "@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"
+    "@ggui-ai/design": "0.21.0",
+    "@ggui-ai/gadgets": "0.21.0",
+    "@ggui-ai/sandbox": "0.21.0",
+    "@ggui-ai/ui-visual-tester": "0.21.0",
+    "@ggui-ai/wire": "0.21.0"
   },
   "devDependencies": {
     "@google/adk": "^2.0.0",
@@ -248,9 +252,9 @@
     "react-dom": "^19.0.0",
     "tsup": "^8.5.0",
     "vitest": "^3.2.6",
-    "@ggui-ai/mcp-server-core": "0.19.0",
-    "@ggui-ai/project-config": "0.19.0",
-    "@ggui-ai/protocol": "0.19.0"
+    "@ggui-ai/mcp-server-core": "0.21.0",
+    "@ggui-ai/project-config": "0.21.0",
+    "@ggui-ai/protocol": "0.21.0"
   },
   "engines": {
     "node": ">=22.0.0"

package/src/adapters/base.ts

@@ -14,6 +14,13 @@ export interface AdapterConfig {
   apiKey?: string;
   /** Use Bedrock instead of direct API (Claude only) */
   useBedrock?: boolean;
+  /**
+   * ggui#1185 — run on the machine's own Claude Code login instead of a key.
+   * Claude SDK adapter only. The adapter strips every provider key from the
+   * spawned env and pins the run tool-less, config-less and non-bare (see
+   * `claude/claude-code-login.ts`). Opt-in; absent ⇒ key-based auth.
+   */
+  claudeCodeLogin?: boolean;
   /**
    * Thinking level for models with extended thinking (Gemini 3.x Flash
    * via the Interactions API). Mirrors the API's `thinking_level` enum —
@@ -129,5 +136,6 @@ export function hasCredentials(
 ): boolean {
   if (config.apiKey) return true;
   if (config.useBedrock) return true;
+  if (config.claudeCodeLogin) return true;
   return envVarNames.some((name) => !!process.env[name]);
 }

package/src/adapters/claude/claude-code-login.ts

@@ -0,0 +1,73 @@
+/**
+ * ggui#1185 — generation through the machine's own Claude Code login.
+ *
+ * The Claude SDK adapter spawns the Claude Code binary. Given no provider
+ * key, that binary authenticates with whatever `claude` is logged in as on
+ * the machine — the operator's own plan. This module holds the three
+ * things that make such a run honest and reproducible:
+ *
+ *   1. {@link CLAUDE_CODE_LOGIN_CREDENTIAL} — the sentinel a `ProviderKeyRef`
+ *      carries in place of a key, the same shape `bedrock-iam` already uses
+ *      for "authenticate with ambient credentials, not a key I hold".
+ *   2. {@link stripProviderKeyEnv} — no provider key may reach the spawned
+ *      process: the binary prefers an env key over its login, so a stale
+ *      `ANTHROPIC_API_KEY` would silently take the run off the login path.
+ *   3. {@link claudeCodeLoginQueryOptions} — the SDK options that keep the
+ *      run bounded: no built-in tool (`tools: []`), no `~/.claude` settings,
+ *      hooks or MCP servers leaking in (`settingSources: []`). Not
+ *      `--bare`, either: on the SDK's bundled binary `-p` reads the login
+ *      store as it always has, so no flag is needed — and the flag it
+ *      would be (`--no-bare`) is one that binary rejects; see the note on
+ *      the function below.
+ *
+ * Opt-in, off by default; the default stays a provider key. The copy that
+ * names what this does lives with the CLI flag that enables it.
+ */
+
+import type { Options } from "@anthropic-ai/claude-agent-sdk";
+
+/** Sentinel credential: "no key — use the machine's Claude Code login". */
+export const CLAUDE_CODE_LOGIN_CREDENTIAL = "claude-code-login" as const;
+
+/**
+ * Every env name the spawned binary would read as a credential or an
+ * endpoint override ahead of its login. Stripped whole, never rewritten.
+ */
+export const PROVIDER_KEY_ENV_NAMES = [
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
+] as const;
+
+/** A copy of `env` without any provider key or endpoint override. */
+export function stripProviderKeyEnv(
+  env: Readonly<Record<string, string | undefined>>
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  const drop: ReadonlySet<string> = new Set(PROVIDER_KEY_ENV_NAMES);
+  for (const [k, v] of Object.entries(env)) {
+    if (v !== undefined && !drop.has(k)) out[k] = v;
+  }
+  return out;
+}
+
+/**
+ * The SDK `query()` options a login-path run is pinned to — typed as the
+ * SDK's own `Options` members, so a change in the SDK's shape is a compile
+ * error here and never a silently ignored key.
+ *
+ * NOT pinned: `--no-bare`. The SDK spawns its BUNDLED binary (2.1.229 for
+ * SDK 0.3.229), which has no bare mode and rejects the flag outright
+ * (`error: unknown option '--no-bare'`, measured 2026-09-21 on the first
+ * live turn of the login client); the machine's own `claude` (2.1.274)
+ * accepts it, which is where the earlier probe measured it. On the
+ * bundled binary `-p` reads the login store as it always has. If a later
+ * SDK bundles a binary where bare becomes the `-p` default, the flag
+ * comes back here — with the SDK version bump, measured again.
+ */
+export type ClaudeCodeLoginQueryOptions = Required<Pick<Options, "tools" | "settingSources">>;
+
+export function claudeCodeLoginQueryOptions(): ClaudeCodeLoginQueryOptions {
+  return { tools: [], settingSources: [] };
+}

package/src/adapters/claude/sdk.ts

@@ -13,6 +13,7 @@ import type { ClaudeSdkConfig, GenerateParams } from '../base';
 import type { AdapterResult, ProviderName, AdapterMode } from '../types';
 import { createArtifacts, processMessage } from './message-parser';
 import { createToolMcpServer } from './tool-bridge';
+import { claudeCodeLoginQueryOptions, stripProviderKeyEnv } from './claude-code-login';
 
 export class ClaudeSdkAdapter extends GeneratorAdapter {
   readonly provider: ProviderName = 'claude';
@@ -40,7 +41,11 @@ export class ClaudeSdkAdapter extends GeneratorAdapter {
     const { query } = await import('@anthropic-ai/claude-agent-sdk');
 
     // Build environment from config or process.env
-    const env = buildEnv(cfg.env);
+    // ggui#1185 — on the login path no provider key may reach the binary:
+    // it prefers an env key over its login, so a stale one would take the
+    // run off this path without a word.
+    const login = cfg.claudeCodeLogin === true;
+    const env = login ? stripProviderKeyEnv(buildEnv(cfg.env)) : buildEnv(cfg.env);
 
     const artifacts = createArtifacts();
     const onProgress = cfg.onProgress;
@@ -72,6 +77,8 @@ export class ClaudeSdkAdapter extends GeneratorAdapter {
         allowDangerouslySkipPermissions: true,
         ...(cfg.cliPath && { pathToClaudeCodeExecutable: cfg.cliPath }),
         ...(cfg.stderr && { stderr: cfg.stderr }),
+        // ggui#1185 — tool-less, config-less, non-bare; the model is pinned above.
+        ...(login ? claudeCodeLoginQueryOptions() : {}),
       },
     })) {
       processMessage(

package/src/adapters/generation-dispatch.ts

@@ -102,6 +102,12 @@ export interface GenerationDispatchParams {
      * today's single screenshot at `viewport`.
      */
     canvases?: readonly CanvasClass[];
+    /**
+     * ggui#1195 — per-canvas viewport override for the in-loop round: the
+     * box the composer targeted (`rendering.viewport`) so the round judges
+     * the same box. See `VisualEvalConfig.canvasViewports`.
+     */
+    canvasViewports?: Partial<Readonly<Record<CanvasClass, { width: number; height: number }>>>;
   };
   /** Quality config controlling eval tiers and improvement behavior */
   qualityConfig?: QualityConfig;
@@ -179,7 +185,12 @@ export interface GenerationDispatchParams {
    * means `constrained` (byte-identical to the pre-`designMode` path).
    */
   designMode?: DesignMode;
-  /** Rendering canvas class for the `free` prompt — see `CreateHarnessInput.canvas`. */
+  /**
+   * Rendering canvas class — see `CreateHarnessInput.canvas`. Absent, the
+   * harness derives it from `shellType` × `screen` (ggui#1117), so the axis
+   * checks always judge for the canvas the generation renders on; the
+   * `free` prompt renders it, the constrained prompt ignores it.
+   */
   canvas?: CanvasClass;
   /** The app's generation profile (#991). */
   profile?: GenerationProfileInput;
@@ -296,7 +307,13 @@ export async function dispatchGeneration(
       : {}),
     // Design mode + canvas — the harness carries them to every leg.
     ...(params.designMode !== undefined ? { designMode: params.designMode } : {}),
-    ...(params.canvas !== undefined ? { canvas: params.canvas } : {}),
+    // ggui#1117 — the canvas is ALWAYS carried: a stated one, else the class
+    // shell × screen renders on. The axis checks judge for it
+    // (`universal.root_width_cap` stands down without one — which is what every
+    // served generation got, since the serving runtime states no canvas); the
+    // constrained prompt ignores it (INVARIANT 1, `design-mode.pin.test.ts`),
+    // so the prompt digests do not move; the free prompt renders it as before.
+    canvas: params.canvas ?? canvasForRendering(params.shellType, params.screen),
     ...(params.profile !== undefined ? { profile: params.profile } : {}),
     // Policy is pre-resolved at the dispatch boundary so `createHarness`
     // stays free of experiment plumbing. `resolveHarnessPolicy` applies

package/src/adapters/openai/raw.ts

@@ -10,6 +10,7 @@ import { GeneratorAdapter, hasCredentials } from '../base';
 import type { AdapterConfig, GenerateParams } from '../base';
 import type { AdapterResult, ToolDefinition, ProviderName, AdapterMode } from '../types';
 import { zodToJsonSchema } from '../tool-bridge';
+import { splitOpenAiUsage } from './tokens';
 import {
   createCapture,
   captureSourceCode,
@@ -54,6 +55,9 @@ export class OpenAiRawAdapter extends GeneratorAdapter {
     const capture = createCapture();
     let totalInputTokens = 0;
     let totalOutputTokens = 0;
+    // OpenAI's input token count INCLUDES cached tokens; track the cached
+    // subset so tokens.input reports NON-cached input (ggui#1186).
+    let totalCachedInputTokens = 0;
     let turnsUsed = 0;
     let allTextOutput = '';
 
@@ -74,6 +78,8 @@ export class OpenAiRawAdapter extends GeneratorAdapter {
       if (response.usage) {
         totalInputTokens += response.usage.input_tokens ?? 0;
         totalOutputTokens += response.usage.output_tokens ?? 0;
+        totalCachedInputTokens +=
+          response.usage.input_tokens_details?.cached_tokens ?? 0;
       }
 
       // Process output items
@@ -156,11 +162,11 @@ export class OpenAiRawAdapter extends GeneratorAdapter {
       sourceCode: capture.sourceCode,
       stream: capture.stream,
       generatorMeta: capture.generatorMeta,
-      tokens: {
-        input: totalInputTokens,
-        output: totalOutputTokens,
-        total: totalInputTokens + totalOutputTokens,
-      },
+      ...splitOpenAiUsage(
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedInputTokens,
+      ),
       generationTimeMs: Date.now() - startTime,
       turnsUsed,
     };

package/src/adapters/openai/sdk.ts

@@ -6,6 +6,7 @@
 import { GeneratorAdapter, hasCredentials } from '../base';
 import type { AdapterConfig, GenerateParams } from '../base';
 import type { AdapterResult, ProviderName, AdapterMode } from '../types';
+import { splitOpenAiUsage } from './tokens';
 import {
   createCapture,
   captureSourceCode,
@@ -87,17 +88,19 @@ export class OpenAiSdkAdapter extends GeneratorAdapter {
     const usage = result.state.usage;
     const inputTokens = usage.inputTokens;
     const outputTokens = usage.outputTokens;
+    // OpenAI's input token count INCLUDES cached tokens; sum the cached
+    // subset across per-request details (ggui#1186).
+    const cachedInputTokens = (usage.inputTokensDetails ?? []).reduce(
+      (sum, details) => sum + (details.cached_tokens ?? 0),
+      0,
+    );
 
     return {
       compiledCode: capture.compiledCode,
       sourceCode: capture.sourceCode,
       stream: capture.stream,
       generatorMeta: capture.generatorMeta,
-      tokens: {
-        input: inputTokens,
-        output: outputTokens,
-        total: inputTokens + outputTokens,
-      },
+      ...splitOpenAiUsage(inputTokens, outputTokens, cachedInputTokens),
       generationTimeMs: Date.now() - startTime,
       turnsUsed: result.rawResponses?.length ?? 0,
     };

package/src/adapters/openai/tokens.ts

@@ -0,0 +1,67 @@
+import type { AdapterResult } from '../types';
+
+/**
+ * Split an OpenAI usage report into the shared cross-adapter token
+ * convention (ggui#1186).
+ *
+ * OpenAI reports the cached prompt tokens as a SUBSET already counted
+ * inside its input token total (`usage.input_tokens` on the Responses
+ * API, `usage.inputTokens` on the Agents SDK, both INCLUDING cached
+ * tokens). Anthropic (and OpenRouter's Anthropic passthrough) instead
+ * report `input_tokens` EXCLUDING cache reads, with cache reads as a
+ * separate field.
+ *
+ * The whole fleet reads one convention: **`tokens.input` is the
+ * NON-cached input; `cacheReadTokens` is the cache-hit subset.** Cost
+ * and observability consumers price/aggregate `input` at the full input
+ * rate and `cacheReadTokens` at the cache-read rate, so the cached
+ * portion must appear in exactly one of the two — never both. Reporting
+ * OpenAI's cache-inclusive `input_tokens` as `tokens.input` while also
+ * populating `cacheReadTokens` would double-count the cached tokens (it
+ * inflates `$/gen` and breaks `render_cache_metric`'s `cacheReadPct`
+ * denominator). So the OpenAI adapters subtract the cached subset here.
+ *
+ * `total` is the full processed footprint (non-cached input + cache
+ * reads + output = `inputTokensInclCached + outputTokens`), matching the
+ * Claude adapter's `total` (input + cacheCreation + cacheRead + output);
+ * OpenAI has no explicit cache-creation step, so there is no
+ * `cacheCreationTokens` term.
+ */
+export function splitOpenAiUsage(
+  inputTokensInclCached: number,
+  outputTokens: number,
+  cachedTokens: number,
+): { tokens: AdapterResult['tokens']; cacheReadTokens: number } {
+  return splitCacheInclusiveUsage(inputTokensInclCached, outputTokens, cachedTokens);
+}
+
+/**
+ * The provider-neutral form of the split above (ggui#1186, third site): any
+ * provider whose reported input token count INCLUDES the cached part of the
+ * prompt — OpenAI's `input_tokens` + `input_tokens_details.cached_tokens`,
+ * Gemini's `total_input_tokens` + `total_cached_tokens` and
+ * `promptTokenCount` + `cachedContentTokenCount` ("the cached part of the
+ * prompt", per the SDK) — is split the same way into the non-cached input and
+ * the cached subset, so `input` is never double-counted and `total` stays the
+ * full footprint.
+ */
+export function splitCacheInclusiveUsage(
+  inputTokensInclCached: number,
+  outputTokens: number,
+  cachedTokens: number,
+): { tokens: AdapterResult['tokens']; cacheReadTokens: number } {
+  // Never let a malformed usage report drive input negative.
+  const cacheRead = Math.min(
+    Math.max(cachedTokens, 0),
+    Math.max(inputTokensInclCached, 0),
+  );
+  const nonCachedInput = Math.max(inputTokensInclCached, 0) - cacheRead;
+  return {
+    tokens: {
+      input: nonCachedInput,
+      output: outputTokens,
+      total: nonCachedInput + cacheRead + outputTokens,
+    },
+    cacheReadTokens: cacheRead,
+  };
+}

package/src/adapters/provider-router.ts

@@ -12,6 +12,7 @@
 // legacy) still needs the wire-canonical anthropic id → cross-region
 // profile id upcast.
 
+import { CLAUDE_CODE_LOGIN_CREDENTIAL, PROVIDER_KEY_ENV_NAMES } from './claude/claude-code-login';
 import type { LlmRoute } from '@ggui-ai/protocol';
 
 /**
@@ -58,6 +59,13 @@ export function getBedrockModelId(model: string): string {
 }
 
 export interface RoutingDecision {
+  /**
+   * Named only for the Claude Code login path (ggui#1185): the caller passed
+   * {@link CLAUDE_CODE_LOGIN_CREDENTIAL} as the key, every provider key is
+   * cleared from the env below, and the adapter pins the SDK options that keep
+   * the run tool-less, config-less and non-bare. Absent ⇒ key-based auth.
+   */
+  readonly auth?: 'claude-code-login';
   /**
    * Upstream model id the dispatch adapter will pass to the provider
    * SDK. For most routes this is `route.model` verbatim — the typed
@@ -143,6 +151,13 @@ function clearSiblings(
  */
 export function resolveRoute(input: RoutingInput): RoutingDecision {
   const { route, apiKey, env } = input;
+  if (apiKey === CLAUDE_CODE_LOGIN_CREDENTIAL && route.provider !== 'anthropic') {
+    throw new Error(
+      `${route.provider}:${route.model} cannot use the claude-code-login credential — ` +
+        `the machine's Claude Code login authenticates the Claude Code binary only; ` +
+        `pick an anthropic route or supply a ${route.provider} API key.`,
+    );
+  }
 
   switch (route.provider) {
     case 'openai': {
@@ -215,6 +230,19 @@ export function resolveRoute(input: RoutingInput): RoutingDecision {
     }
 
     case 'anthropic': {
+      if (apiKey === CLAUDE_CODE_LOGIN_CREDENTIAL) {
+        // ggui#1185: no key reaches the spawned binary — it authenticates with
+        // the machine's own Claude Code login. Every provider key AND every
+        // sibling is cleared, because the binary prefers an env key over its
+        // login and a stale one would silently take the run off this path.
+        const cleared: Record<string, undefined> = {};
+        for (const k of PROVIDER_KEY_ENV_NAMES) cleared[k] = undefined;
+        return {
+          model: route.model,
+          env: { ...cleared, ...clearSiblings(new Set()) },
+          auth: 'claude-code-login',
+        };
+      }
       if (apiKey) {
         return {
           model: route.model,

package/src/adapters/types.ts

@@ -88,7 +88,7 @@ export interface AdapterResult {
   subagentsUsed?: string[];
   /** Tokens written to prompt cache (Claude-specific) */
   cacheCreationTokens?: number;
-  /** Tokens read from prompt cache (Claude-specific) */
+  /** Tokens read from prompt cache (Claude / OpenRouter / OpenAI). */
   cacheReadTokens?: number;
   /** SDK session ID for evaluation loop resume (Claude SDK-specific) */
   sdkSessionId?: string;

package/src/boilerplate/generate.ts

@@ -246,8 +246,20 @@ export function generateBoilerplate(
     }
 
     const toolNote = tool ? ` (label "${label}", nextStep hint → ${tool})` : "";
+    // ggui#1190: the control's copy is the contract's label, VERBATIM — stated for
+    // EVERY action (it used to appear only beside a `nextStep` hint), because the
+    // model given `"Confirm & Schedule"` in the contract block wrote
+    // `'Confirm Schedule'`. The rule lives in DATA_PARAMETERIZATION rule 4; this is
+    // its reminder beside the action, and the axis check
+    // `universal.action_label_dropped` names the drop when both are ignored.
+    // ggui#1244: it rides the payload type's doc comment, NOT the hook line. Placed
+    // on the hook line directly before the once-hint below, the two read as the
+    // control's spec and gemini-3.5-flash-lite guarded the repeatable Save 8/8;
+    // here, with the hook line back to its earlier bytes, 5/24 — within noise of
+    // the rate before either hint moved (1/8) — while one-time commitments stayed
+    // guarded 40/40 across three providers and every label stayed verbatim (Exp 009).
     actionTypeAliases.push(
-      `/** Action payload: ${desc || label}${toolNote} */\ntype ${typeName} = ${tsType};`
+      `/** Action payload: ${desc || label}${toolNote} — control copy: "${label}" VERBATIM */\ntype ${typeName} = ${tsType};`
     );
     // Inline signature tells the LLM exactly how to call this action
     const callSig = tsType === "void" ? "() => void — fire and forget" : `(data: ${tsType}) => void`;
@@ -255,9 +267,12 @@ export function generateBoilerplate(
     // 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.
+    // which actions are meant once. It is NOT inert, whatever Exp 002b measured
+    // for a different site comment (adoption 1/36): Exp 009 (ggui#1244) removed
+    // it and one-time scheduling went armed on all three providers (guarded 9/12
+    // against 24/24), and a second hint placed beside it turned it into an
+    // instruction for every action. So it stays, ALONE on the hook line — what
+    // sits next to it is part of what it says.
     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,7 +213,7 @@ 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. **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.
+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. An action's control shows the contract's \`label\` VERBATIM — every character, including \`&\`, \`/\`, \`–\` and quotes — never paraphrased, shortened or re-cased (\`"Confirm & Schedule"\` is not \`"Confirm Schedule"\`).
 5. Props interface must be typed and exported.`;
 
 /**

package/src/create-ui-generator.ts

@@ -298,16 +298,25 @@ export function createUiGenerator(
       // structurally into the dispatch call instead. `route.env`
       // already carries exactly the key(s) that would have gone into
       // `process.env`, so no extra resolution work is needed here.
-      const routeOverride = 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',
-          }
-        : undefined;
+      //
+      // ggui#1185 — the login path has NO key to write anywhere: the
+      // route decision `auth: 'claude-code-login'` is carried as
+      // `routeOverride.claudeCodeLogin` in BOTH env modes, because the
+      // flag is the only way the decision reaches `createAgent` /
+      // `createVisionAgent` (which select the login client on it).
+      const routeOverride =
+        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',
+              }
+            : undefined;
 
       try {
         const tools = createGeneratorTools({

package/src/evaluation/axis-checks/checks/universal.ts

@@ -8,6 +8,7 @@ import { LUCIDE_ICON_NAMES, maxWidth as CONTAINER_MAX_WIDTH } from "@ggui-ai/des
 import { CANVAS_VIEWPORTS, type CanvasClass } from "../../../design-mode.js";
 import type { EvalIssue } from "../../types-public.js";
 import type { AxisCheck, AxisCheckInput } from "../types.js";
+import type { DataContract } from "@ggui-ai/protocol";
 import {
   getRequiredPropNames,
   mkIssue,
@@ -499,6 +500,91 @@ function runRootWidthCap(input: AxisCheckInput): EvalIssue[] {
   ];
 }
 
+// ── universal.action_label_dropped (ggui#1190 — the transcription-drop guard) ─
+// The GUARD half of #1190: the model transcribes an actionSpec label onto a
+// control but DROPS a special character ("Confirm & Schedule" → "Confirm
+// Schedule"), because the verbatim label is not at the write-site. This check
+// NAMES that class on the bench and guards regression; the fix (carry the
+// verbatim label / render it from data) lands separately, so #1190 stays open.
+// WARN-class, deterministic, and tuned to flag ONLY the high-confidence drop.
+
+const LABEL_SPECIAL_CHAR = /[^a-z0-9\s]/i;
+const normText = (s: string): string => s.toLowerCase().replace(/\s+/g, " ").trim();
+const alnumText = (s: string): string => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+
+/**
+ * Extract the VISIBLE rendered text of a component — JSX text nodes (with `{…}`
+ * expression containers stripped, nesting-aware) plus visible string
+ * attributes (aria-label / placeholder / title / alt). Deliberately excludes
+ * identifiers and call args: `useAction('confirmSchedule')` and the `const
+ * confirmSchedule` binding must NOT count as the label "Confirm & Schedule"
+ * appearing, or every action would false-match its own camelCase name.
+ */
+function visibleText(sourceCode: string): string {
+  // JSX text nodes: `>text<`. Excluding `>` from the run (`[^<>]`) skips the
+  // `=>` arrow-body conflation — an arrow's `>` is followed by code then a
+  // `>`, never text then a `<`, so only true tag-close→text→tag runs match,
+  // and identifiers (`const confirmSchedule`, `useAction('confirmSchedule')`)
+  // are never between `>` and `<`. `{…}` expression children are stripped so an
+  // expression's identifiers don't count as visible text.
+  const jsx = (sourceCode.match(/>([^<>]*)</g) ?? [])
+    .map((m) => m.slice(1, -1).replace(/\{[^}]*\}/g, " "))
+    .join(" ");
+  let attrs = "";
+  const attrRx = /\b(?:aria-label|placeholder|title|alt)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+  let m: RegExpExecArray | null;
+  while ((m = attrRx.exec(sourceCode)) !== null) attrs += " " + (m[1] ?? m[2] ?? "");
+  return jsx + " " + attrs;
+}
+
+/**
+ * Find actionSpec labels whose special-character content was dropped from the
+ * generated source. FALSE-POSITIVE-SAFE by construction — flags ONLY when the
+ * label's alphanumeric words appear CONTIGUOUSLY in the source but the full
+ * label (with its "&", "/", "+" …) does not, i.e. a clean transcription drop.
+ * Every ambiguous shape is exempt: labels rendered from data (`.label`
+ * anywhere), labels with no special char (nothing to drop), labels present
+ * verbatim, entity-encoded `&` (`&amp;` — the words stop being contiguous, so
+ * no flag), and very short labels. Presence-ANYWHERE, not wiring-scoped, on
+ * purpose: if the label's text appears anywhere we never flag.
+ */
+export function findDroppedActionLabels(
+  sourceCode: string,
+  contract: DataContract | undefined,
+): Array<{ readonly name: string; readonly label: string }> {
+  const actionSpec = contract?.actionSpec;
+  if (actionSpec === undefined) return [];
+  // Component renders any label from data → it does not transcribe → exempt all.
+  if (/\.label\b/.test(sourceCode)) return [];
+  const vis = visibleText(sourceCode);
+  const normVis = normText(vis);
+  const alnumVis = alnumText(vis);
+  const out: Array<{ name: string; label: string }> = [];
+  for (const [name, entry] of Object.entries(actionSpec)) {
+    const label = entry.label;
+    if (typeof label !== "string" || label.length === 0 || label === name) continue;
+    if (!LABEL_SPECIAL_CHAR.test(label)) continue; // no special char → nothing to drop
+    if (alnumText(label).length < 3) continue; // too short to match confidently
+    if (normVis.includes(normText(label))) continue; // present verbatim in visible text → correct
+    // The label's words appear contiguously in the VISIBLE text but the full
+    // label (with its punctuation) does not → a character was dropped.
+    if (alnumVis.includes(alnumText(label))) out.push({ name, label });
+  }
+  return out;
+}
+
+function runActionLabelDropped(input: AxisCheckInput): EvalIssue[] {
+  if (input.compiledCode === null) return [];
+  return findDroppedActionLabels(input.sourceCode, input.contract).map(({ name, label }) =>
+    mkIssue(
+      "universal.action_label_dropped",
+      `The action "${name}" declares label "${label}", but the rendered control appears to drop its "${label.replace(/[a-z0-9\s]/gi, "").trim()}": the label's words are in the generated source, the full label is not — a transcription drop (ggui#1190).`,
+      `Render the label EXACTLY as the contract states it — button text should be the verbatim \`actionSpec.${name}.label\`, or render it from data (\`{x.label}\`), never a re-typed copy that drops "&", "/", "+", etc.`,
+      "warn",
+    ),
+  );
+}
+
 export const UNIVERSAL_CHECKS: readonly AxisCheck[] = [
   {
     id: "universal.icon_name_known",
@@ -524,6 +610,12 @@ export const UNIVERSAL_CHECKS: readonly AxisCheck[] = [
     values: ALL_RENDER_VALUES,
     run: runRootWidthCap,
   },
+  {
+    id: "universal.action_label_dropped",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runActionLabelDropped,
+  },
   {
     id: "universal.terminal_action_unguarded",
     axis: "render",