@ggui-ai/ui-gen 0.27.0 → 0.29.0

package/src/coding-agent/tools.ts

@@ -11,9 +11,10 @@
 import * as esbuild from 'esbuild';
 import { AgentWorkspace } from './workspace';
 import { getSoftWarnings } from './self-check';
+import { restoreReactImport } from '../boilerplate/react-hooks.js';
 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 { AxisCheck, AxisCheckInput, EvalIssue } 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';
@@ -24,6 +25,21 @@ import type {
 } from './types';
 import { DEFAULT_DESIGN_MODE, type DesignMode } from '../design-mode.js';
 
+/**
+ * ggui#1876 — the auto-commit line's axis field: the F/W counts, then the check ids behind them, so a
+ * WARN the model saw at a turn is attributable in the log (the `[WARN]` text otherwise appears only at
+ * the final evaluation). `0F/1W[W:universal.tint_category_in_words]`; nothing appended at `0F/0W`.
+ * The `<n>F/<n>W` prefix is unchanged, so anything that reads the counts reads them as before. An
+ * issue with no `subcategory` (the axis checks always set one, as their id) is named by its category.
+ */
+export function axisCountsWithIds(issues: readonly EvalIssue[]): string {
+  const idOf = (i: EvalIssue): string => i.subcategory ?? i.category;
+  const warns = issues.filter((i) => i.result === 'warn').map(idOf);
+  const fails = issues.filter((i) => i.result !== 'warn').map(idOf);
+  const groups = [...(fails.length > 0 ? [`F:${fails.join(',')}`] : []), ...(warns.length > 0 ? [`W:${warns.join(',')}`] : [])];
+  return `${fails.length}F/${warns.length}W${groups.length > 0 ? `[${groups.join(' ')}]` : ''}`;
+}
+
 /**
  * Extract documentation for a single component from the full primitives docs.
  * Returns ~200-500 tokens instead of 43K.
@@ -106,7 +122,14 @@ async function autoCommit(
   // No post-compile formatting — the generated TSX is built as-is.
   // (Prettier auto-format was removed; it added a dependency + repair
   // churn without a quality gain.)
-  const formatted = raw;
+  // ggui#1932: the boilerplate's DO NOT EDIT React import is code's to keep — restored here, before
+  // the build and tier-0, so a dropped hook never becomes a refusal the model spends a turn on.
+  const restore = restoreReactImport(raw);
+  if (restore.added.length > 0) {
+    workspace.write(restore.source);
+    console.log(`[coding-agent] react-import restored: ${restore.added.map((h) => `+${h}`).join(',')}`);
+  }
+  const formatted = restore.source;
 
   // Build with esbuild — keep all imports (react, @ggui-ai/design)
   // esbuild.transform() passes them through as-is, the runtime resolves them
@@ -197,7 +220,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} | axis=${axisRun === undefined ? 'off' : `${axisIssues.length - axisWarnings.length}F/${axisWarnings.length}W`}`,
+    `[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' : axisCountsWithIds(axisIssues)}`,
   );
   if (violations.length > 0) {
     for (const v of violations) {

package/src/create-ui-generator.ts

@@ -40,7 +40,7 @@ import type {
   ModelRef,
   AppGenerationProfileEffort,
 } from "@ggui-ai/protocol";
-import { isGeneratorId, modelRefOfRoute } from "@ggui-ai/protocol";
+import { DEFAULT_MODEL as PROTOCOL_DEFAULT_MODEL, isGeneratorId, modelRefOfRoute } from "@ggui-ai/protocol";
 import type { GadgetCatalogAdapter } from "@ggui-ai/gadgets";
 import type {
   GenerationMetadata,
@@ -85,7 +85,9 @@ import type { AgentConfig } from "./harness/llm-router.js";
 
 /** The slug for the OSS default seed generator. */
 const DEFAULT_TIER: GeneratorTier = "default";
-const DEFAULT_MODEL: ModelRef = "anthropic/claude-haiku-4-5";
+// ggui#1794 — the open-source default is protocol's, one source: a default switch moves one constant
+// (`@ggui-ai/protocol` `DEFAULT_MODEL`), never two. ggui#1743 moved it to Haiku 5.5 on benchmark's receipt.
+const DEFAULT_MODEL: ModelRef = PROTOCOL_DEFAULT_MODEL;
 
 export interface CreateUiGeneratorOptions {
   /**

package/src/design-mode.ts

@@ -18,6 +18,8 @@
 //     blueprint-reuse shape, and brand-bearing color via the closed
 //     `--ggui-color-*` token manifest (no literals, no fallbacks).
 
+import type { CanvasClass } from "@ggui-ai/design/rendering";
+
 export const DESIGN_MODES = ["constrained", "free"] as const;
 
 export type DesignMode = (typeof DESIGN_MODES)[number];
@@ -38,15 +40,8 @@ export const DEFAULT_DESIGN_MODE: DesignMode = "constrained";
 // breakpoints. `canvasForViewportWidth` is monotonic in width per
 // display mode (pinned by `design-mode.test.ts`).
 
-export const CANVAS_CLASSES = [
-  "xs-chat-card",
-  "mobile-fullscreen-small",
-  "md",
-  "lg",
-  "xl",
-] as const;
-
-export type CanvasClass = (typeof CANVAS_CLASSES)[number];
+// The vocabulary itself lives in `@ggui-ai/design/rendering`, where the runtime reads it too.
+export { CANVAS_CLASSES, type CanvasClass } from "@ggui-ai/design/rendering";
 
 export interface CanvasViewport {
   readonly width: number;

package/src/evaluation/axis-checks/checks/state-merge.ts

@@ -12,6 +12,7 @@ import {
   getEntityCollections,
   getMutatedEntityCollections,
   mkIssue,
+  seedsFromProp,
 } from "../helpers.js";
 
 function runStateSeededFromProps(input: AxisCheckInput): EvalIssue[] {
@@ -21,10 +22,7 @@ function runStateSeededFromProps(input: AxisCheckInput): EvalIssue[] {
   const entities = getMutatedEntityCollections(input.contract, all);
   const issues: EvalIssue[] = [];
   for (const e of entities) {
-    const re = new RegExp(
-      `useState(?:<[^>]*>)?\\s*\\([\\s\\S]{0,400}?props\\.${e.name}\\b`,
-    );
-    if (re.test(src)) continue;
+    if (seedsFromProp(src, e.name)) continue;
     issues.push(
       mkIssue(
         "state.merge.seeded_from_props",
@@ -57,7 +55,7 @@ function runNoHardcodedEntities(input: AxisCheckInput): EvalIssue[] {
       mkIssue(
         "state.merge.no_hardcoded_entities",
         `Hardcoded entity array literal (multiple objects with "${idField}") in the component — entity data should come from state/props.`,
-        `Remove the literal array. Seed state from props.{entityProp} and merge updates via stream.`,
+        `Remove the literal array: this data comes from ${all.filter((e) => e.idField === idField).map((e) => `props.${e.name}`).join(" / ") || "props"}. Read it there (\`?? []\` for an absent value, never a literal default), seed state from it, and merge updates via stream.`,
       ),
     );
   }

package/src/evaluation/axis-checks/checks/state-payload.ts

@@ -12,6 +12,7 @@ import {
   getInitialValuePropNames,
   getSubmitActions,
   mkIssue,
+  seedsFromProp,
 } from "../helpers.js";
 
 function runSubmitHookPresent(input: AxisCheckInput): EvalIssue[] {
@@ -79,34 +80,6 @@ function runStateCoversPayload(input: AxisCheckInput): EvalIssue[] {
   return issues;
 }
 
-/**
- * Whether a `useState` initializer reads `props.<name>`: directly, or through a local bound from
- * it (`const initial = normalize(props.initialProfile)` then `useState(initial.name)`, or a
- * destructure `const { name } = props.initialProfile ?? {}` then `useState(name)`). The property
- * this check guards is "form state is seeded from the prop", not a spelling: ggui#1261's Exp 011
- * cell re-seeded correctly through a normalized local, was refused, and spent a turn restoring
- * the literal form.
- */
-function seedsFromProp(src: string, name: string): boolean {
-  const propRef = `props\\??\\.${name}\\b`;
-  const initializerReads = (ref: string): boolean =>
-    new RegExp(`useState(?:<[^>]*>)?\\s*\\([\\s\\S]{0,400}?${ref}`).test(src);
-  if (initializerReads(propRef)) return true;
-  const locals = new Set<string>();
-  for (const m of src.matchAll(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*(?::[^=]{1,80})?=\\s*[^;]{0,300}?${propRef}`, "g"))) {
-    const id = m[1];
-    if (id !== undefined) locals.add(id);
-  }
-  for (const m of src.matchAll(new RegExp(`(?:const|let|var)\\s*\\{([^}]{1,400})\\}\\s*=\\s*[^;]{0,300}?${propRef}`, "g"))) {
-    for (const part of (m[1] ?? "").split(",")) {
-      const id = part.split(":").pop()?.split("=")[0]?.trim();
-      if (id !== undefined && /^\w+$/.test(id)) locals.add(id);
-    }
-  }
-  for (const id of locals) if (initializerReads(`\\b${id}\\b`)) return true;
-  return false;
-}
-
 function runInitialValuesSeeded(input: AxisCheckInput): EvalIssue[] {
   if (input.compiledCode === null) return [];
   const src = input.sourceCode;

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

@@ -0,0 +1,197 @@
+// packages/ui-gen/src/evaluation/axis-checks/checks/tint.ts
+//
+// ggui#1846 — the categorical `tint` fill's usage rules, as WARNINGS. The kit
+// gives `Box` / `Card` eight theme-tracked steps (`tint-1` … `tint-8`) for DATA
+// categories. The rules (ggui-team-cdo's, taught in the system prompt) are a
+// property of the rendered card, and from source each can only be read by a
+// heuristic over names or JSX structure. A heuristic that FAILS loops a
+// generation that is correct but trips it, so these warn: the model sees the
+// repair line as feedback, nothing blocks, and the follow and false-fire rates
+// are measured. An out-of-range step fails through the prop's own type instead.
+//
+// Not checked here: "the same category bound to two steps in one card". Reading
+// that needs data flow, not the tag's text.
+
+import type { EvalIssue } from "../../types-public.js";
+import type { AxisCheck, AxisCheckInput } from "../types.js";
+import { mkIssue } from "../helpers.js";
+
+const ALL_RENDER_VALUES = [
+  "static", "list", "grid", "spatial", "timeline", "chart", "master-detail",
+] as const;
+
+/** One tinted `Box` / `Card`: the tag, the `tint` value's source text, and the JSX between its open and close tags. */
+export interface TintedElement {
+  readonly tag: "Box" | "Card";
+  readonly tint: string;
+  /** The JSX between the open and close tag; empty when self-closing. */
+  readonly inner: string;
+  /** For a self-closing element, its following siblings up to the next close tag (a swatch's label); else empty. */
+  readonly next: string;
+}
+
+interface OpenTag {
+  readonly attrs: string;
+  readonly end: number;
+  readonly selfClosing: boolean;
+}
+
+/**
+ * Read a JSX open tag whose `<Name` starts at `from`. Braces and string
+ * literals are skipped as units, so an `onClick={() => …}` arrow does not end
+ * the tag the way a `[^<>]` pattern would.
+ */
+function scanOpenTag(src: string, from: number, nameLength: number): OpenTag | null {
+  let depth = 0;
+  let quote = "";
+  for (let i = from + 1 + nameLength; i < src.length; i++) {
+    const ch = src[i];
+    if (quote !== "") {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+    } else if (ch === ">" && depth === 0) {
+      const attrs = src.slice(from + 1 + nameLength, i);
+      return { attrs, end: i + 1, selfClosing: attrs.trimEnd().endsWith("/") };
+    }
+  }
+  return null;
+}
+
+/** The value of a top-level `tint=` attribute, braces or quotes included; null when absent. */
+function readTintAttr(attrs: string): string | null {
+  let depth = 0;
+  let quote = "";
+  for (let i = 0; i < attrs.length; i++) {
+    const ch = attrs[i];
+    if (quote !== "") {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+    else if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+    else if (depth === 0 && /\s/.test(attrs[i - 1] ?? " ")) {
+      const m = /^tint\s*=\s*/.exec(attrs.slice(i));
+      if (m === null) continue;
+      const v = i + m[0].length;
+      const open = attrs[v];
+      if (open === '"' || open === "'") {
+        const close = attrs.indexOf(open, v + 1);
+        return close < 0 ? null : attrs.slice(v, close + 1);
+      }
+      if (open !== "{") return null;
+      let d = 0;
+      for (let j = v; j < attrs.length; j++) {
+        if (attrs[j] === "{") d++;
+        else if (attrs[j] === "}" && --d === 0) return attrs.slice(v, j + 1);
+      }
+      return null;
+    }
+  }
+  return null;
+}
+
+/** Every tinted `Box` / `Card` in the source, with its inner JSX (empty when self-closing). */
+export function findTintedElements(sourceCode: string): TintedElement[] {
+  const found: TintedElement[] = [];
+  for (const m of sourceCode.matchAll(/<(Box|Card)\b/g)) {
+    const tag = m[1] === "Card" ? "Card" : "Box";
+    const from = m.index ?? 0;
+    const open = scanOpenTag(sourceCode, from, tag.length);
+    if (open === null) continue;
+    const tint = readTintAttr(open.attrs);
+    if (tint === null) continue;
+    if (open.selfClosing) {
+      const close = sourceCode.indexOf("</", open.end);
+      found.push({ tag, tint, inner: "", next: sourceCode.slice(open.end, close < 0 ? sourceCode.length : close) });
+      continue;
+    }
+    // Walk to the matching close tag, counting nested opens of the same name.
+    const tagRx = new RegExp(`<(/?)${tag}\\b`, "g");
+    tagRx.lastIndex = open.end;
+    let depth = 1;
+    let end = sourceCode.length;
+    for (let t = tagRx.exec(sourceCode); t !== null; t = tagRx.exec(sourceCode)) {
+      if (t[1] === "/") {
+        if (--depth === 0) {
+          end = t.index;
+          break;
+        }
+        continue;
+      }
+      const nested = scanOpenTag(sourceCode, t.index, tag.length);
+      if (nested === null) break;
+      tagRx.lastIndex = nested.end;
+      if (!nested.selfClosing) depth++;
+    }
+    found.push({ tag, tint, inner: sourceCode.slice(open.end, end), next: "" });
+  }
+  return found;
+}
+
+const STATE_WORD_RX = /\b(status|state|isLive|live|draft|signal|error|success|warning|danger|isActive|active|selected|isSelected|online|offline|pending|loading|disabled)\b/i;
+
+/** Text a reader sees inside the cell: a text primitive, a JSX expression child, or literal JSX text. */
+function hasWords(inner: string): boolean {
+  if (/<(Text|Heading|Label|Badge|Caption|Link)\b/.test(inner)) return true;
+  if (/\{[^{}]+\}/.test(inner.replace(/\b[a-zA-Z]+=\{[^{}]*\}/g, ""))) return true;
+  return />\s*[^<>{}\s][^<>{}]*</.test(`>${inner}<`);
+}
+
+function runTintStateBound(input: AxisCheckInput): EvalIssue[] {
+  if (input.compiledCode === null) return [];
+  const bound = findTintedElements(input.sourceCode).filter((e) => e.tint.startsWith("{") && STATE_WORD_RX.test(e.tint));
+  if (bound.length === 0) return [];
+  return [
+    mkIssue(
+      "universal.tint_state_bound",
+      `\`tint\` reads as bound to a state (${bound.map((e) => `\`${e.tint}\``).join(", ")}) — tints are for data categories, never for state.`,
+      "A status takes live, draft or signal, not a tint. Keep `tint` for a data category (series, lane, kind, group), and show state with its own props.",
+      "warn",
+    ),
+  ];
+}
+
+function runTintCategoryInWords(input: AxisCheckInput): EvalIssue[] {
+  if (input.compiledCode === null) return [];
+  const tinted = findTintedElements(input.sourceCode);
+  if (tinted.length === 0) return [];
+  if (/\blegend\b/i.test(input.sourceCode)) return [];
+  if (tinted.every((e) => hasWords(e.inner) || hasWords(e.next))) return [];
+  return [
+    mkIssue(
+      "universal.tint_category_in_words",
+      "A tinted cell carries no words, and the card has no legend — colour is the only way to tell its category.",
+      "Give this cell a label, or add a legend to the card. The category is always also in words.",
+      "warn",
+    ),
+  ];
+}
+
+const MUTED_TONE_RX = /\btone\s*=\s*["'](subtle|muted)["']/;
+
+function runTintMutedText(input: AxisCheckInput): EvalIssue[] {
+  if (input.compiledCode === null) return [];
+  if (!findTintedElements(input.sourceCode).some((e) => MUTED_TONE_RX.test(e.inner))) return [];
+  return [
+    mkIssue(
+      "universal.tint_muted_text",
+      'Muted text (`tone="subtle"` / `tone="muted"`) sits on a tint — it can read under 4.5:1 there.',
+      "Text on a tint is the theme's ink only, one short line (a label, a symbol, a value). Put secondary or muted text beside the cell or in the legend.",
+      "warn",
+    ),
+  ];
+}
+
+export const TINT_CHECKS: readonly AxisCheck[] = [
+  { id: "universal.tint_state_bound", axis: "render", values: ALL_RENDER_VALUES, run: runTintStateBound },
+  { id: "universal.tint_category_in_words", axis: "render", values: ALL_RENDER_VALUES, run: runTintCategoryInWords },
+  { id: "universal.tint_muted_text", axis: "render", values: ALL_RENDER_VALUES, run: runTintMutedText },
+];

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

@@ -249,14 +249,128 @@ export function getInitialValuePropNames(contract?: DataContract): string[] {
 // Source scanning helpers
 // =============================================================================
 
+/**
+ * The top-level property keys of the object literal whose `{` is at `open`, read by
+ * walking brackets and skipping strings, so a nested object or a `}` inside a string
+ * neither ends the literal early nor contributes keys. `undefined` when `open` is not a `{`.
+ */
+function objectLiteralKeysAt(src: string, open: number): string[] | undefined {
+  if (src[open] !== "{") return undefined;
+  const keys: string[] = [];
+  let depth = 0;
+  let expectKey = true;
+  for (let i = open; i < src.length; i++) {
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") {
+      // Skip the string; a quoted top-level key ("name": …) is a key too.
+      let j = i + 1;
+      while (j < src.length && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+      if (depth === 1 && expectKey && /^\s*:/.test(src.slice(j + 1))) keys.push(src.slice(i + 1, j));
+      i = j;
+      expectKey = false;
+      continue;
+    }
+    if (c === "{" || c === "[" || c === "(") {
+      depth++;
+      if (depth === 1) expectKey = true;
+      continue;
+    }
+    if (c === "}" || c === "]" || c === ")") {
+      depth--;
+      if (depth === 0) return keys;
+      continue;
+    }
+    if (depth !== 1) continue;
+    if (c === ",") {
+      expectKey = true;
+      continue;
+    }
+    if (expectKey && /[A-Za-z_$]/.test(c ?? "")) {
+      const m = /^([A-Za-z_$][\w$]*)\s*(:|,|\})/.exec(src.slice(i));
+      // `key: value`, or the shorthand `key,` / `key }`.
+      if (m !== null && m[1] !== undefined) keys.push(m[1]);
+      expectKey = false;
+    }
+  }
+  return keys;
+}
+
+/** The argument texts of the call whose `(` is at `open`, split on top-level commas. */
+function callArgsAt(src: string, open: number): string[] {
+  const args: string[] = [];
+  let depth = 0;
+  let start = open + 1;
+  for (let i = open; i < src.length; i++) {
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+      i = j;
+      continue;
+    }
+    if (c === "(" || c === "{" || c === "[") depth++;
+    else if (c === ")" || c === "}" || c === "]") {
+      depth--;
+      if (depth === 0) {
+        args.push(src.slice(start, i));
+        return args;
+      }
+    } else if (c === "," && depth === 1) {
+      args.push(src.slice(start, i));
+      start = i + 1;
+    }
+  }
+  return args;
+}
+
+/**
+ * The keys an initial-state argument provides: an object literal (`{ … }`), a lazy
+ * initializer returning one (`() => ({ … })`), or an identifier bound to one in the same
+ * file (`const INITIAL: Form = { … }`, also behind a lazy `() => INITIAL`).
+ */
+function initialStateKeys(src: string, argStart: number, argText: string): string[] {
+  const lead = argText.length - argText.trimStart().length;
+  let at = argStart + lead;
+  let text = argText.trim();
+  const lazy = /^\(\s*\)\s*=>\s*\(?\s*/.exec(text);
+  if (lazy !== null) {
+    at += lazy[0].length;
+    text = text.slice(lazy[0].length);
+  }
+  if (text.startsWith("{")) return objectLiteralKeysAt(src, at) ?? [];
+  const ident = /^([A-Za-z_$][\w$]*)\s*\)?\s*$/.exec(text);
+  if (ident === null || ident[1] === undefined) return [];
+  // One binding, or none: a name declared twice (shadowed, or re-declared in another scope) is
+  // ambiguous, and ambiguity reads as absence, so the check can never pass on the wrong binding.
+  const decls = [...src.matchAll(new RegExp(`(?:const|let|var)\\s+${ident[1]}\\s*(?::[^=]{1,200})?=\\s*`, "g"))];
+  const decl = decls.length === 1 ? decls[0] : undefined;
+  if (decl === undefined) return [];
+  return objectLiteralKeysAt(src, (decl.index ?? 0) + decl[0].length) ?? [];
+}
+
 /**
  * Collect all key names that appear as state slots — either keys inside a
  * `useState({ ... })` object literal, or standalone state variables.
+ *
+ * ggui#1790 — also the initial-state shapes the inline-literal patterns cannot see, each
+ * idiomatic React: `useState(INITIAL)` with `const INITIAL = { … }` in the file, a lazy
+ * initializer `useState(() => ({ … }))`, and `useReducer(reducer, { … } | INITIAL)`. Missing
+ * them made `state.payload.covers_submit` report every payload key missing on a form that held
+ * them all, and the model, with nothing real to fix, spent the turn cap rewording a comment.
  */
 export function collectStateKeys(src: string): Set<string> {
   const keys = new Set<string>();
   const varRe = /const\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useState/g;
   for (const m of src.matchAll(varRe)) keys.add(m[1]);
+  // ggui#1791 — a contextSpec slot is state too: the boilerplate binds each slot as
+  // `const [x, setX] = useGguiContext<T>('x')` under a DO-NOT-EDIT banner, so a form
+  // whose fields are context slots holds every payload key there and cannot move them
+  // into useState. Both the binding's name and the slot's name count.
+  const contextRe = /const\s*\[\s*(\w+)\s*,\s*\w+\s*\]\s*=\s*useGguiContext\s*(?:<[^>]*>)?\s*\(\s*['"`](\w+)['"`]/g;
+  for (const m of src.matchAll(contextRe)) {
+    keys.add(m[1]);
+    keys.add(m[2]);
+  }
   const objRe = /useState(?:<[^>]*>)?\s*\(\s*\{([\s\S]*?)\}\s*\)/g;
   for (const m of src.matchAll(objRe)) {
     const keyRe = /(?:^|,)\s*(\w+)\s*:/g;
@@ -267,6 +381,17 @@ export function collectStateKeys(src: string): Set<string> {
     const keyRe = /(?:^|,)\s*(\w+)\s*:/g;
     for (const km of m[1].matchAll(keyRe)) keys.add(km[1]);
   }
+  // ggui#1790 — the initial-state argument, resolved: useState's first, useReducer's second.
+  for (const m of src.matchAll(/\b(useState|useReducer)\s*(?:<[^>]*>)?\s*\(/g)) {
+    const open = (m.index ?? 0) + m[0].length - 1;
+    const args = callArgsAt(src, open);
+    const which = m[1] === "useReducer" ? 1 : 0;
+    const arg = args[which];
+    if (arg === undefined) continue;
+    let argStart = open + 1;
+    for (let k = 0; k < which; k++) argStart += (args[k]?.length ?? 0) + 1;
+    for (const key of initialStateKeys(src, argStart, arg)) keys.add(key);
+  }
   return keys;
 }
 
@@ -286,6 +411,127 @@ export function isMultiStepPrompt(prompt: string): boolean {
 // Issue factory
 // =============================================================================
 
+/**
+ * Whether a `useState` initializer reads `props.<name>`: directly, or through a local bound from
+ * it (`const initial = normalize(props.initialProfile)` then `useState(initial.name)`, or a
+ * destructure `const { name } = props.initialProfile ?? {}` then `useState(name)`). The property
+ * this check guards is "form state is seeded from the prop", not a spelling: ggui#1261's Exp 011
+ * cell re-seeded correctly through a normalized local, was refused, and spent a turn restoring
+ * the literal form. ggui#1869: a nested generic (`useState<Array<Task>>(…)`), `props?.`,
+ * destructured props and destructured component parameters are all correct seeding too, and
+ * `state.merge.seeded_from_props` — a FAIL — refused them.
+ */
+export function seedsFromProp(src: string, name: string): boolean {
+  const propRef = `props\\??\\.${name}\\b`;
+  const inits = useStateInitializers(src);
+  const anyInitReads = (rx: RegExp): boolean => inits.some((t) => rx.test(t));
+  if (anyInitReads(new RegExp(`\\b${propRef}`))) return true;
+  const locals = new Set<string>();
+  for (const m of src.matchAll(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*(?::[^=]{1,80})?=\\s*[^;]{0,300}?\\b${propRef}`, "g"))) {
+    const id = m[1];
+    if (id !== undefined) locals.add(id);
+  }
+  // `const { a, b } = props.<name> ?? {}` — every name bound reads the prop.
+  for (const m of src.matchAll(new RegExp(`(?:const|let|var)\\s*\\{([^}]{1,400})\\}\\s*=\\s*[^;]{0,300}?\\b${propRef}`, "g"))) {
+    for (const part of (m[1] ?? "").split(",")) {
+      const id = part.split(":").pop()?.split("=")[0]?.trim();
+      if (id !== undefined && /^\w+$/.test(id)) locals.add(id);
+    }
+  }
+  // `const { <name>: alias } = props` and `export default function Component({ <name>: alias }: Props)` — only the
+  // binding of <name>, and only the component's own parameter (a helper's destructured parameter is not its props).
+  const fromProps = /(?:const|let|var)\s*\{([^}]{1,400})\}\s*(?::[^=]{1,200})?=\s*props\b(?!\s*\??\.)|export\s+default\s+function\s*\w*\s*\(\s*\{([^}]{1,400})\}/g;
+  for (const m of src.matchAll(fromProps)) {
+    for (const part of (m[1] ?? m[2] ?? "").split(",")) {
+      const [key, alias] = part.split(":");
+      if (key?.split("=")[0]?.trim() !== name) continue;
+      const id = (alias ?? key).split("=")[0]?.trim();
+      if (id !== undefined && /^\w+$/.test(id)) locals.add(id);
+    }
+  }
+  for (const id of locals) if (anyInitReads(new RegExp(`\\b${id}\\b`))) return true;
+  return seedsContextSlotFromProp(src, [new RegExp(`\\b${propRef}`), ...[...locals].map((id) => new RegExp(`\\b${id}\\b`))]);
+}
+
+/**
+ * ggui#1869 — a generated context slot is seeded without any `useState`. The boilerplate
+ * declares each slot as `const [value, setValue] = useGguiContext<T>('key')`, the runtime owns
+ * its state, and the hook takes no initial value, so a form built on slots can only pre-fill in
+ * two ways, and both count:
+ * - an effect calls a slot setter with an argument that reads the prop
+ *   (`useEffect(() => { if (p.name && !name) setName(p.name); }, [props.initialProfile])`);
+ * - a slot's value falls back to the prop (`const nameValue = name ?? props.initialProfile?.name`).
+ * A setter called from an event handler is not seeding (it runs on a click, not on mount), and a
+ * prop read that is merely near a slot is not one either.
+ */
+function seedsContextSlotFromProp(src: string, readsProp: readonly RegExp[]): boolean {
+  const reads = (text: string): boolean => readsProp.some((rx) => rx.test(text));
+  const values: string[] = [];
+  const setters: string[] = [];
+  for (const m of src.matchAll(/(?:const|let|var)\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useGguiContext\b/g)) {
+    if (m[1] !== undefined) values.push(m[1]);
+    if (m[2] !== undefined) setters.push(m[2]);
+  }
+  if (values.length === 0) return false;
+  for (const v of values) {
+    for (const m of src.matchAll(new RegExp(`(?<![.\\w$])${v}\\s*\\?\\?\\s*([^;\\n]{1,200})`, "g"))) {
+      if (reads(m[1] ?? "")) return true;
+    }
+  }
+  for (const body of callArguments(src, /\buse(?:Layout)?Effect\b/g)) {
+    for (const setter of setters) {
+      for (const arg of callArguments(body, new RegExp(`\\b${setter}\\b`, "g"))) if (reads(arg)) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * The argument text of every `useState(...)` call. A type argument is skipped with its angle
+ * brackets balanced (`useState<Record<string, Task[]>>(…)`; an arrow's `=>` inside it is not a
+ * close), and the argument runs to its matching paren, string literals skipped as units.
+ */
+function useStateInitializers(src: string): string[] {
+  return callArguments(src, /\buseState\b/g);
+}
+
+/**
+ * The argument text of every call to a name `callee` matches (a global regex). A type argument is
+ * skipped with its angle brackets balanced, and the argument runs to its matching paren, string
+ * literals skipped as units. A match not followed by `(` is not a call and is skipped.
+ */
+function callArguments(src: string, callee: RegExp): string[] {
+  const out: string[] = [];
+  for (const m of src.matchAll(callee)) {
+    let i = (m.index ?? 0) + m[0].length;
+    while (/\s/.test(src[i] ?? "")) i++;
+    if (src[i] === "<") {
+      let depth = 0;
+      for (; i < src.length; i++) {
+        if (src[i] === "<") depth++;
+        else if (src[i] === ">" && src[i - 1] !== "=" && --depth === 0) break;
+      }
+      i++;
+      while (/\s/.test(src[i] ?? "")) i++;
+    }
+    if (src[i] !== "(") continue;
+    const start = i + 1;
+    let depth = 0;
+    let quote = "";
+    for (; i < src.length; i++) {
+      const ch = src[i];
+      if (quote !== "") {
+        if (ch === "\\") i++;
+        else if (ch === quote) quote = "";
+      } else if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+      else if (ch === "(") depth++;
+      else if (ch === ")" && --depth === 0) break;
+    }
+    out.push(src.slice(start, i));
+  }
+  return out;
+}
+
 export function mkIssue(
   subcategory: string,
   description: string,

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

@@ -5,6 +5,7 @@
 
 import type { AxisCheck } from "./types.js";
 import { UNIVERSAL_CHECKS } from "./checks/universal.js";
+import { TINT_CHECKS } from "./checks/tint.js";
 import { STATE_MERGE_CHECKS } from "./checks/state-merge.js";
 import { STATE_UI_AFFORDANCE_CHECKS } from "./checks/state-ui-affordance.js";
 import { REALTIME_CHECKS } from "./checks/realtime.js";
@@ -16,6 +17,7 @@ import { EXTRA_CHECKS } from "./extras.js";
 
 export const REGISTRY: readonly AxisCheck[] = [
   ...UNIVERSAL_CHECKS,
+  ...TINT_CHECKS,
   ...STATE_MERGE_CHECKS,
   ...STATE_UI_AFFORDANCE_CHECKS,
   ...REALTIME_CHECKS,