@ggui-ai/ui-gen 0.26.0 → 0.28.0

package/src/evaluation/loop.ts

@@ -1,6 +1,7 @@
 // packages/ui-gen/src/evaluation/loop.ts
 
 import { query, type McpServerConfig } from '@anthropic-ai/claude-agent-sdk';
+import { sdkToolPins } from '../adapters/claude/sdk-tool-pins';
 import { runEvaluation } from './evaluator';
 import {
   extractCompiledCodeFromMessage,
@@ -39,8 +40,13 @@ export interface EvaluationLoopOptions {
     cwd?: string;
     /** MCP servers available to the fix agent */
     mcpServers?: Record<string, McpServerConfig>;
-    /** Tools the fix agent is allowed to call */
+    /** Tool names to approve. Absent → every tool of every server in `mcpServers` (ggui#1714). */
     allowedTools?: string[];
+    /**
+     * CLI built-in tools to offer the fix agent (e.g. `['Write']`). Default: none.
+     * An explicit opt-in: a built-in that writes or executes acts on the host (ggui#1714).
+     */
+    builtinTools?: readonly string[];
     /** LLM model for fix rounds */
     model?: string;
     /** Environment variables (includes BYOK credentials) */
@@ -90,6 +96,18 @@ export async function runEvaluationLoop(
   let round = 0;
   const maxRounds = Math.min(config.maxRounds ?? 3, MAX_EVAL_ROUNDS_HARD_LIMIT);
 
+  // ggui#1714 — a fix round runs with no CLI built-ins unless asked for. With no
+  // MCP server and no built-in either, the fix agent has nothing that can return
+  // code, and every fix round would silently hand back the original: refuse.
+  const offersATool =
+    Object.keys(generatorOptions?.mcpServers ?? {}).length > 0 || (generatorOptions?.builtinTools?.length ?? 0) > 0;
+  if (maxRounds > 1 && !offersATool) {
+    throw new Error(
+      'runEvaluationLoop: a fix round needs a tool that can return code — pass generatorOptions.mcpServers ' +
+        "(e.g. a server with compile_component) or opt into a built-in with generatorOptions.builtinTools (e.g. ['Write']).",
+    );
+  }
+
   while (round < maxRounds) {
     round++;
 
@@ -145,12 +163,15 @@ export async function runEvaluationLoop(
         maxTurns: 15,
         maxBudgetUsd: config.maxBudgetPerFix,
         env,
-        permissionMode: 'bypassPermissions',
-        allowDangerouslySkipPermissions: true,
         ...(cliPath && { pathToClaudeCodeExecutable: cliPath }),
         ...(generatorOptions?.cwd && { cwd: generatorOptions.cwd }),
         ...(generatorOptions?.mcpServers && { mcpServers: generatorOptions.mcpServers }),
-        ...(generatorOptions?.allowedTools && { allowedTools: generatorOptions.allowedTools }),
+        // ggui#1714 — no CLI built-ins unless asked for, no host settings, no permission bypass.
+        ...sdkToolPins({
+          mcpServers: generatorOptions?.mcpServers,
+          allowedTools: generatorOptions?.allowedTools,
+          builtinTools: generatorOptions?.builtinTools,
+        }),
         ...(generatorOptions?.model && { model: generatorOptions.model }),
         ...(generatorOptions?.stderr && { stderr: generatorOptions.stderr }),
       },

package/src/evaluation/message-parsing.ts

@@ -10,6 +10,7 @@
  */
 
 import type { EvaluationResult } from './types';
+import { sourceCodeFromToolUse } from '../adapters/claude/source-capture';
 
 // ── SDK message type aliases ────────────────────────────────────────
 
@@ -137,13 +138,14 @@ export function extractCompiledCodeFromMessage(message: SdkMessage): string | un
 // ── sourceCode extraction ───────────────────────────────────────────
 
 /**
- * Extract source code from an assistant's Write tool_use message.
+ * Extract source code from an assistant message's tool_use blocks.
  *
- * Looks for `tool_use` blocks with `name === 'Write'` and returns
- * the `input.content` string. If multiple Write calls exist, returns
- * the last one (the final version).
+ * Reads the bridged compile tool (`*__compile_component`, `input.code`)
+ * and the CLI's `Write` (`input.content`, offered only by opt-in), by the
+ * one rule in `adapters/claude/source-capture.ts` (ggui#1714). If several
+ * calls carry source, returns the last one (the final version).
  *
- * Used by: loop.ts, generator.ts
+ * Used by: loop.ts
  */
 export function extractSourceCodeFromMessage(message: SdkMessage): string | undefined {
   if ((message.type as string) !== 'assistant') return undefined;
@@ -155,12 +157,9 @@ export function extractSourceCodeFromMessage(message: SdkMessage): string | unde
   if (!Array.isArray(content)) return undefined;
 
   for (const block of content) {
-    if (block.type === 'tool_use' && block.name === 'Write') {
-      const input = block.input as { content?: string } | undefined;
-      if (input?.content) {
-        sourceCode = input.content;
-      }
-    }
+    if (block.type !== 'tool_use') continue;
+    const value = sourceCodeFromToolUse(block.name, block.input);
+    if (value !== undefined) sourceCode = value;
   }
 
   return sourceCode;
@@ -183,7 +182,7 @@ export function extractCompiledCode(messages: SdkMessage[]): string | undefined
 }
 
 /**
- * Scan all messages for the last sourceCode from Write tool_use.
+ * Scan all messages for the last sourceCode a tool_use carried.
  *
  * Convenience wrapper for tests and one-shot extraction.
  */

package/src/evaluation/types-public.ts

@@ -376,6 +376,10 @@ export interface CanvasJudgeRecord {
   /**
    * ggui#1687 — the model asked for, and every model the provider said answered this canvas's calls (scoring and
    * criteria), deduplicated. `served` is empty when no provider named one: unknown, never "the requested model".
+   * When the request names an alias and the provider echoes the alias (measured on a hosted route, 125 of 125
+   * canvases), `served` confirms the alias was honoured but cannot tell two snapshots behind it apart. A judge that
+   * must is pinned to a dated snapshot id instead. With the alias, a snapshot change shows only as a step on a date in
+   * the judge's pooled within-call spread, read by week. That is a read someone runs, not a monitor.
    */
   readonly models?: { readonly requested: string; readonly served: readonly string[] };
 }

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

package/src/taught-tokens.ts

@@ -18,13 +18,12 @@ import { consumedTokenManifest } from "@ggui-ai/design/themes";
  * closed-set check still admits them: a card that references one is valid wherever this release
  * renders it.
  *
- * - ggui#1494 — the control edges (`controlOutline`, `controlAccentOutline`): derived and completed
- *   from this release; taught from the next.
+ * Empty today. The control edges (`controlOutline`, `controlAccentOutline`, ggui#1494) were held here
+ * until every serving and rollback runtime declared them; the derivation (`10a0c00f2`) is in every
+ * release from tag 17 on, so they are taught from ggui#1697, in the same change as the prompt rule that
+ * teaches a control's edge.
  */
-export const NOT_YET_TAUGHT_TOKENS: ReadonlySet<string> = new Set([
-  "--ggui-color-controlAccentOutline",
-  "--ggui-color-controlOutline",
-]);
+export const NOT_YET_TAUGHT_TOKENS: ReadonlySet<string> = new Set<string>([]);
 
 /** The manifest as the model is taught it. */
 export const taughtTokenManifest: readonly string[] = consumedTokenManifest.filter(