@ggui-ai/ui-gen 0.27.0 → 0.28.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ggui-ai/ui-gen",
-  "version": "0.27.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.",
+  "version": "0.28.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": [
     "ggui",
@@ -189,9 +189,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.27.0",
-    "@ggui-ai/project-config": "0.27.0",
-    "@ggui-ai/protocol": "0.27.0"
+    "@ggui-ai/project-config": "0.28.0",
+    "@ggui-ai/mcp-server-core": "0.28.0",
+    "@ggui-ai/protocol": "0.28.0"
   },
   "peerDependenciesMeta": {
     "@google/adk": {
@@ -233,11 +233,11 @@
     "openai": "^7.9.0",
     "typescript": "^5.0.0",
     "zod": "^4.3.6",
-    "@ggui-ai/design": "0.27.0",
-    "@ggui-ai/sandbox": "0.27.0",
-    "@ggui-ai/gadgets": "0.27.0",
-    "@ggui-ai/ui-visual-tester": "0.27.0",
-    "@ggui-ai/wire": "0.27.0"
+    "@ggui-ai/sandbox": "0.28.0",
+    "@ggui-ai/gadgets": "0.28.0",
+    "@ggui-ai/wire": "0.28.0",
+    "@ggui-ai/ui-visual-tester": "0.28.0",
+    "@ggui-ai/design": "0.28.0"
   },
   "devDependencies": {
     "@google/adk": "^2.0.0",
@@ -252,9 +252,9 @@
     "react-dom": "^19.0.0",
     "tsup": "^8.5.0",
     "vitest": "^3.2.6",
-    "@ggui-ai/mcp-server-core": "0.27.0",
-    "@ggui-ai/project-config": "0.27.0",
-    "@ggui-ai/protocol": "0.27.0"
+    "@ggui-ai/mcp-server-core": "0.28.0",
+    "@ggui-ai/project-config": "0.28.0",
+    "@ggui-ai/protocol": "0.28.0"
   },
   "engines": {
     "node": ">=22.0.0"

package/src/adapters/provider-router.ts

@@ -29,6 +29,7 @@ import type { LlmRoute } from '@ggui-ai/protocol';
 export function getBedrockModelId(model: string): string {
   const BEDROCK_MAP: Record<string, string> = {
     'anthropic/claude-haiku-4-5': 'us.anthropic.claude-haiku-4-5-20251001-v1:0',
+    'anthropic/claude-haiku-5-5': 'us.anthropic.claude-haiku-5-5', // listed ACTIVE in us-east-1 (ggui#1743)
     'anthropic/claude-sonnet-4-6': 'us.anthropic.claude-sonnet-4-6',
     'anthropic/claude-opus-4-6': 'us.anthropic.claude-opus-4-6-v1:0',
     // Claude 5-family (ggui#706, strings verified 2026-09-02 against

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/evaluation/axis-checks/checks/state-merge.ts

@@ -57,7 +57,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/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;
 }
 

package/src/evaluation/evaluator.ts

@@ -218,9 +218,9 @@ function buildEvalResult(
 
 function getDefaultEvalModel(provider: string): string {
   switch (provider) {
-    case 'claude': return 'claude-haiku-4-5-20251001';
+    case 'claude': return 'claude-haiku-5-5';
     case 'openai': return 'gpt-5.6-luna';
     case 'google': return 'gemini-3.5-flash-lite';
-    default: return 'claude-haiku-4-5-20251001';
+    default: return 'claude-haiku-5-5';
   }
 }

package/src/evaluation/llm-evaluator.ts

@@ -568,13 +568,13 @@ Use 'fail' only for pervasive design system violations. Use 'warn' for isolated
 function getDefaultEvalModel(provider: string): string {
   switch (provider) {
     case 'claude':
-      return 'claude-haiku-4-5-20251001';
+      return 'claude-haiku-5-5';
     case 'openai':
       return 'gpt-5.6-luna';
     case 'google':
       return 'gemini-3.5-flash-lite';
     default:
-      return 'claude-haiku-4-5-20251001';
+      return 'claude-haiku-5-5';
   }
 }
 

package/src/evaluation/visual-evaluator.ts

@@ -2004,7 +2004,7 @@ function parseCriteriaAnswers(raw: unknown): { answers?: CriteriaAnswer[]; count
 
 function getDefaultVisualModel(provider: 'claude' | 'google'): string {
   switch (provider) {
-    case 'claude': return 'claude-haiku-4-5-20251001';
+    case 'claude': return 'claude-haiku-5-5';
     case 'google': return 'gemini-3-flash-preview';
   }
 }

package/src/harness/coding/assemble-result.ts

@@ -132,6 +132,7 @@ export async function assembleGenerationResult(
         : telemetry.evalResult,
     // ggui#404 — present only when the same-exchange guard ended the run.
     ...(telemetry.sameExchangeBreak !== undefined ? { sameExchangeBreak: telemetry.sameExchangeBreak } : {}),
+    ...(telemetry.sameFailureBreak !== undefined ? { sameFailureBreak: telemetry.sameFailureBreak } : {}),
     needsBackgroundImprovement,
     selfCheckPassed: telemetry.selfCheckPassed,
     timing,

package/src/harness/coding/dupe-break.ts

@@ -102,6 +102,11 @@ export interface DupeBreakState {
    *  information-free — the model learned nothing it didn't already
    *  have. 1 = first occurrence; 2 = one repeat (nudge); 3 = break. */
   consecutiveIdenticalExchanges: number;
+  /** ggui#1791 — for each failure signature ({@link failureSignatures}), how
+   *  many failed writes (`apply_changes` / `rewrite`) have reported it since
+   *  the last write that passed, whatever the patch and whatever failed in
+   *  between. Cleared when a write passes. */
+  failureCounts: Map<string, number>;
 }
 
 /**
@@ -147,6 +152,70 @@ export const SAME_EXCHANGE_NUDGE =
   "you already have and emit an apply_changes (or scoped) call now; one " +
   "more identical repeat terminates the run.";
 
+/**
+ * ggui#1791 — the failures a failed write reported, one signature per failing
+ * check, with what changes between two identical failures removed: every
+ * digit (line and column numbers, counts) and runs of whitespace.
+ *
+ * A self-check result lists its violations as `[category] description` lines;
+ * each one is its own signature, so a check that fails on every turn reads as
+ * the same failure whether or not another check fails beside it. A result with
+ * no violation line (a build error, a rejected patch) is one signature: its
+ * text without the `Committed <oid>: "<message>"` line, which carries a fresh
+ * oid and the model's own message every turn.
+ *
+ * The patch fingerprint above keys on the PATCH, so the same failure under a
+ * different patch each turn (a reworded comment, a moved line) never reads as
+ * stuck, and a run goes to the turn cap. These key on the FAILURE.
+ */
+export function failureSignatures(resultText: string): string[] {
+  const norm = (text: string): string => text.replace(/[0-9]+/g, "#").replace(/\s+/g, " ").trim();
+  const violations = [...resultText.matchAll(/^\[[^\]\n]+\] [^\n]+/gm)].map((m) => norm(m[0]));
+  if (violations.length > 0) return [...new Set(violations)];
+  const rest = norm(resultText.replace(/^Committed [^\n]*\n/, ""));
+  return rest.length > 0 ? [rest] : [];
+}
+
+/** The failure a write has reported most often since the last pass, and how often. */
+export interface RepeatedFailure {
+  readonly signature: string;
+  readonly repeats: number;
+}
+
+/**
+ * ggui#1791 — record one failed write: count each of its signatures once, and
+ * return the one now reported most often since the last passing write
+ * (undefined when the result carried no recognisable failure).
+ */
+export function recordWriteFailure(state: DupeBreakState, resultText: string): RepeatedFailure | undefined {
+  let top: RepeatedFailure | undefined;
+  for (const signature of failureSignatures(resultText)) {
+    const repeats = (state.failureCounts.get(signature) ?? 0) + 1;
+    state.failureCounts.set(signature, repeats);
+    if (top === undefined || repeats > top.repeats) top = { signature, repeats };
+  }
+  return top;
+}
+
+/** ggui#1791 — a write passed: every count starts over. */
+export function clearWriteFailures(state: DupeBreakState): void {
+  state.failureCounts.clear();
+}
+
+/** A failure reported for the third time since the last pass ⇒ one explicit nudge. */
+export const SAME_FAILURE_NUDGE_AT = 3;
+
+/** A failure reported for the fifth time since the last pass ⇒ the loop is not
+ *  converging; the caller ends the run, which ships what the turn cap would
+ *  have shipped. */
+export const SAME_FAILURE_BREAK_AT = 5;
+
+/** Appended to the tool result of the {@link SAME_FAILURE_NUDGE_AT}th identical failure. */
+export const SAME_FAILURE_NUDGE =
+  "\n\n[harness] This same failure has now been reported for three of your " +
+  "patches. Changing other code does not clear it: re-read that check above and " +
+  "change exactly what it names. Two more reports of it end the run.";
+
 export function createDupeBreakState(): DupeBreakState {
   return {
     lastFailedPatchFingerprint: null,
@@ -164,6 +233,7 @@ export function createDupeBreakState(): DupeBreakState {
     consecutiveNoToolCalls: 0,
     lastExchangeKey: null,
     consecutiveIdenticalExchanges: 0,
+    failureCounts: new Map(),
   };
 }
 

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

@@ -25,7 +25,7 @@ import {
 import { runEvalRound } from "./run-eval-round.js";
 import type { TokenUsage } from "./run-eval-round.js";
 import type { VisualLegTokens } from "../../evaluation/visual-evaluator.js";
-import type { SameExchangeBreak } from "../result-types.js";
+import type { SameExchangeBreak, SameFailureBreak } from "../result-types.js";
 
 type PreWarmedEvalContext =
   import("../../evaluation/llm-evaluator.js").PreWarmedEvalContext;
@@ -105,6 +105,8 @@ export interface GenerateTelemetry {
    * undefined unless that guard is what stopped the loop.
    */
   sameExchangeBreak: SameExchangeBreak | undefined;
+  /** ggui#1791 — set when the same-failure guard ended the run. */
+  sameFailureBreak: SameFailureBreak | undefined;
   /** Latest compiled code — empty string until the first self-check pass. */
   compiledCode: string;
   /**
@@ -147,6 +149,7 @@ export function createTelemetry(): GenerateTelemetry {
     probeRepairTrigger: undefined,
     contractFeedback: undefined,
     sameExchangeBreak: undefined,
+    sameFailureBreak: undefined,
     compiledCode: "",
     pairedSource: "",
     selfCheckPassed: false,
@@ -223,6 +226,7 @@ export function absorbTurn(telemetry: GenerateTelemetry, turn: CodingTurnResult)
     else telemetry.counters.outcomes.selfCheckFail++;
   }
   if (turn.sameExchangeBreak !== undefined) telemetry.sameExchangeBreak = turn.sameExchangeBreak;
+  if (turn.sameFailureBreak !== undefined) telemetry.sameFailureBreak = turn.sameFailureBreak;
 }
 
 export interface CreateGenerateRunnerInput {

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

@@ -21,7 +21,7 @@ import { executeTool } from "../../coding-agent/tools.js";
 import type { CostTracker } from "../../evaluation/cost-tracker.js";
 import type { LLMAgent } from "../llm-router.js";
 import type { Harness } from "../types-public.js";
-import type { SameExchangeBreak } from "../result-types.js";
+import type { SameExchangeBreak, SameFailureBreak } from "../result-types.js";
 import {
   APPLY_CHANGES_HASHLINE_TOOL,
   APPLY_CHANGES_HASHLINE_TOOL_FLAT,
@@ -38,10 +38,16 @@ import {
 import { LUCIDE_ICON_NAMES } from "@ggui-ai/design";
 import { formatWithHashlines } from "../hashline.js";
 import {
+  clearWriteFailures,
   recordToolExchange,
+  recordWriteFailure,
   SAME_EXCHANGE_BREAK_AT,
   SAME_EXCHANGE_NUDGE,
+  SAME_FAILURE_BREAK_AT,
+  SAME_FAILURE_NUDGE,
+  SAME_FAILURE_NUDGE_AT,
 } from "./dupe-break.js";
+import type { RepeatedFailure } from "./dupe-break.js";
 
 /** Staged process-mode phase machine — also defined in runtime.ts. */
 export type A1Phase = "scaffold" | "fill" | "post";
@@ -254,6 +260,11 @@ export interface CodingTurnResult {
    * control value many exits share. No key on any other turn.
    */
   readonly sameExchangeBreak?: SameExchangeBreak;
+  /**
+   * Set only on the `break` the same-failure guard returns (ggui#1791). No
+   * key on any other turn.
+   */
+  readonly sameFailureBreak?: SameFailureBreak;
 }
 
 /**
@@ -952,6 +963,26 @@ ${closingInstruction}`;
     }
   }
 
+  // ggui#1791 same-failure guard — the patch fingerprint above keys on the
+  // PATCH, so the same failure under a different patch each turn (a reworded
+  // comment, a moved line) never counts as stuck. This keys on the FAILURE:
+  // each failing check a write reports is counted since the last passing
+  // write, whatever failed in between. The third report of one gets a nudge,
+  // the fifth ends the run. A passing write clears the counts; a non-write
+  // tool (cat, icons) changes nothing and leaves them as they were.
+  const isWrite = call.name === "apply_changes" || call.name === "rewrite";
+  let repeatedFailure: RepeatedFailure | undefined;
+  if (ctx.dupeBreak && isWrite) {
+    if (result.done) {
+      clearWriteFailures(ctx.dupeBreak);
+    } else {
+      repeatedFailure = recordWriteFailure(ctx.dupeBreak, result.result);
+      if (repeatedFailure?.repeats === SAME_FAILURE_NUDGE_AT) {
+        augmentedResultText += SAME_FAILURE_NUDGE;
+      }
+    }
+  }
+
   // Send tool result back to close the API contract (Google/OpenAI/OpenRouter)
   // This enables proper session chaining on the next callTools() invocation.
   await codingAgent.sendToolResult([{
@@ -984,6 +1015,30 @@ ${closingInstruction}`;
     };
   }
 
+  if (repeatedFailure !== undefined && repeatedFailure.repeats >= SAME_FAILURE_BREAK_AT) {
+    const signature = repeatedFailure.signature.slice(0, 160);
+    console.log(
+      `[coding-agent] SAME_FAILURE_BREAK | tool=${call.name} | repeats=${repeatedFailure.repeats} | failure=${JSON.stringify(signature.slice(0, 80))} — terminating run (ggui#1791)`,
+    );
+    return {
+      control: "break",
+      compiledCode: "",
+      selfCheckPassed: false,
+      outcome: undefined,
+      phase: undefined,
+      tokens,
+      ...cacheTokens,
+      llmMs,
+      toolMs,
+      lastResultText: augmentedResultText,
+      lastDiffFailed: false,
+      isEvalFeedback: false,
+      iconNamesCache,
+      preWarmedContext,
+      sameFailureBreak: { signature, repeats: repeatedFailure.repeats },
+    };
+  }
+
   // Track whether the diff itself failed to apply (vs applied but had violations)
   const turnDiffFailed = !!result.error && result.result.includes("DIFF");
 

package/src/harness/result-types.ts

@@ -62,6 +62,16 @@ export interface SameExchangeBreak {
   readonly repeats: number;
 }
 
+/**
+ * ggui#1791 — the same-failure guard ended the run: one failing check
+ * (`signature`, its first 160 characters) was reported by this many failed
+ * writes since the last passing one, whatever the patch.
+ */
+export interface SameFailureBreak {
+  readonly signature: string;
+  readonly repeats: number;
+}
+
 export interface GenerationResult extends AdapterResult {
   /** Number of generation passes the harness performed */
   passesUsed: number;
@@ -77,6 +87,8 @@ export interface GenerationResult extends AdapterResult {
   inLoopVisualTokens?: VisualLegTokens;
   /** Set only when the same-exchange guard ended the run (ggui#404); no key otherwise. */
   sameExchangeBreak?: SameExchangeBreak;
+  /** ggui#1791 — set only when the same-failure guard ended the run. */
+  sameFailureBreak?: SameFailureBreak;
   /** Whether background improvement should be spawned (auto-improve mode) */
   needsBackgroundImprovement?: boolean;
   /** Whether at least one commit passed the self-check (compile + type check + lint) */

package/src/index.ts

@@ -22,7 +22,7 @@ export {
 export type { CreateUiGeneratorOptions } from './create-ui-generator.js';
 export type { RuntimeRenderProbeConfig } from './harness/check/runtime-render/adapter.js';
 export type { ProviderRetryInfo } from './harness/llm-router.js';
-export type { GenerationResult, SameExchangeBreak } from './harness/result-types.js';
+export type { GenerationResult, SameExchangeBreak, SameFailureBreak } from './harness/result-types.js';
 // The build identity a stamp outside this package can name: the same
 // digests `createUiGenerator` puts on every result's `metadata.build`, for
 // either design mode — so a harness definition can carry both modes' digests