@ggui-ai/ui-gen 0.5.0-rc.0 → 0.5.0-rc.2

package/dist/adapters/generation-dispatch.d.ts

@@ -1,7 +1,7 @@
 import { EvaluationConfig } from '../evaluation/types.js';
 import { ModelRoles, GenerationResult } from '../harness/result-types.js';
 import { ProviderName, ToolDefinition, AdapterResult } from './types.js';
-import { Q as QualityConfig } from '../types-public-Dl1rJ-yU.js';
+import { Q as QualityConfig } from '../types-public-D9swfbNi.js';
 import { DataContract, JsonObject, GadgetDescriptor } from '@ggui-ai/protocol';
 import { R as RenderingContext } from '../prompts-BVhtH3M1.js';
 import 'zod';

package/dist/adapters/generation-dispatch.js

@@ -4100,10 +4100,23 @@ var init_tag_balance = __esm({
 // src/harness/coding/dupe-break.ts
 var dupe_break_exports = {};
 __export(dupe_break_exports, {
+  SAME_EXCHANGE_BREAK_AT: () => SAME_EXCHANGE_BREAK_AT,
+  SAME_EXCHANGE_NUDGE: () => SAME_EXCHANGE_NUDGE,
   computePatchFingerprint: () => computePatchFingerprint,
   createDupeBreakState: () => createDupeBreakState,
-  errorClassBucket: () => errorClassBucket
+  errorClassBucket: () => errorClassBucket,
+  recordToolExchange: () => recordToolExchange
 });
+function recordToolExchange(state, name, input, resultText) {
+  const key = createHash("sha256").update(name).update("\0").update(JSON.stringify(input) ?? "undefined").update("\0").update(resultText).digest("hex");
+  if (state.lastExchangeKey === key) {
+    state.consecutiveIdenticalExchanges += 1;
+  } else {
+    state.lastExchangeKey = key;
+    state.consecutiveIdenticalExchanges = 1;
+  }
+  return state.consecutiveIdenticalExchanges;
+}
 function createDupeBreakState() {
   return {
     lastFailedPatchFingerprint: null,
@@ -4118,7 +4131,9 @@ function createDupeBreakState() {
     diagnosticBrokeLoopCount: 0,
     recentFailedPatches: [],
     consecutiveBrokenApplies: 0,
-    consecutiveNoToolCalls: 0
+    consecutiveNoToolCalls: 0,
+    lastExchangeKey: null,
+    consecutiveIdenticalExchanges: 0
   };
 }
 function errorClassBucket(errText) {
@@ -4143,8 +4158,11 @@ function computePatchFingerprint(changes, errText) {
   h.update(errBucket);
   return h.digest("hex");
 }
+var SAME_EXCHANGE_BREAK_AT, SAME_EXCHANGE_NUDGE;
 var init_dupe_break = __esm({
   "src/harness/coding/dupe-break.ts"() {
+    SAME_EXCHANGE_BREAK_AT = 3;
+    SAME_EXCHANGE_NUDGE = "\n\n[harness] This is the SAME tool call with the SAME result as your previous turn \u2014 repeating it cannot produce new information. Use what you already have and emit an apply_changes (or scoped) call now; one more identical repeat terminates the run.";
   }
 });
 
@@ -10490,15 +10508,17 @@ async function runCheck(input) {
       (i) => i.result === "fail" && (i.tier === 0 || i.tier === void 0)
     ).length;
     if (cheapTier0Failures === 0) {
-      firedIds.push(check.runtimeRender.id);
-      const runtimeIssues = await check.runtimeRender.run({
+      const outcome = await check.runtimeRender.run({
         sourceCode,
         compiledCode,
         contract,
         fixtureProps: input.fixtureProps
       });
-      issues.push(...runtimeIssues);
-      runtimeRenderIssueCount = runtimeIssues.length;
+      if (outcome.status === "ran") {
+        firedIds.push(check.runtimeRender.id);
+        issues.push(...outcome.issues);
+        runtimeRenderIssueCount = outcome.issues.length;
+      }
     }
   }
   let llmIssueCount = 0;
@@ -13003,13 +13023,18 @@ var PITFALLS = [
     rule: "All design-system primitives are pre-imported by the boilerplate \u2014 do NOT add imports unless absolutely needed.",
     why: "Duplicate imports cause TS errors; the boilerplate already resolves the full primitive surface.",
     foundIn: "pre-#61 baseline"
-  },
-  {
-    id: "stepper-display-only",
-    rule: "`Stepper` is display-only: `steps` is a top-level `const` array and `current` is YOUR `useState` index \u2014 Stepper never stores or advances the step itself.",
-    why: "Data-vs-behavior: navigation state lives in generated code. The steps-as-state failure mode (useState-wrapped step arrays, expecting Stepper to self-advance) crashes with 'function is not iterable' or dead Next buttons.",
-    foundIn: "#306 composite-roster wave (multi-step fragment failure classes)"
   }
+  // ─── stepper-display-only: retired to the CHECK leg (Exp 47 P2) ─────────
+  //
+  // The 6th always-on pitfall ("Stepper is display-only…") was added with
+  // the #306 roster wave, but D8 measured Stepper adoption at 17/18 from
+  // fragment + JSDoc alone — the always-on rule was demonstrably not
+  // load-bearing, and exp66's factorial showed pitfall COUNT (5→6+) is
+  // the dilution-sensitive lever (~+9s blended). Its guidance now ships
+  // as the fix string of the `layout.multi_step.stepper_adopted` axis
+  // check (evaluation/axis-checks/extras.ts) — delivered only to the
+  // multi-step cells that actually violate it.
+  //
   // ─── Provisional pitfalls considered + retired by exp66 n=6 factorial ───
   //
   // The 3 "new" pitfalls below were added in exp61 after OpenAI kanban
@@ -14082,6 +14107,23 @@ var multiStepHasState = {
     ];
   }
 };
+var stepperAdopted = {
+  id: "layout.multi_step.stepper_adopted",
+  axis: "layout",
+  values: ["multi-step"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    if (/<Stepper[\s/>]/.test(input.sourceCode)) return [];
+    return [
+      mkIssue2(
+        "layout.multi_step.stepper_adopted",
+        "Classified as layout=multi-step but the design system's Stepper composite is never rendered.",
+        "Render <Stepper steps={STEPS} current={step} /> above the step body \u2014 STEPS is a top-level const array of step labels and `step` is your own useState index. Stepper is display-only: it never stores or advances the step itself.",
+        "fail"
+      )
+    ];
+  }
+};
 var mixedStreamsHaveHandlers = {
   id: "realtime.mixed.handlers_per_event",
   axis: "realtime",
@@ -14107,6 +14149,7 @@ var EXTRA_CHECKS = [
   swipeTriggerWired,
   composeCrossEntity,
   multiStepHasState,
+  stepperAdopted,
   mixedStreamsHaveHandlers
 ];
 
@@ -14566,9 +14609,9 @@ function toMinimalElement(v) {
     "[runtime-render] host value lacks the element surface (tagName/getAttribute/querySelectorAll)"
   );
 }
-function buildClickUser(userEventModule) {
+function buildClickUser(userEventModule, doc) {
   const setup = getMethod(userEventModule, "setup");
-  const instance = setup ? setup() : userEventModule;
+  const instance = setup ? setup({ document: doc }) : userEventModule;
   const click = getMethod(instance, "click");
   if (!click) {
     throw new Error(
@@ -14767,7 +14810,7 @@ async function runRenderCheck(input) {
       return finalize(issues, t0, 0, 0);
     }
     const container = toMinimalElement(renderResult.container);
-    const user = buildClickUser(userEvent);
+    const user = buildClickUser(userEvent, hostGlobals().document);
     let actionsChecked = 0;
     let streamsChecked = 0;
     try {
@@ -15457,8 +15500,12 @@ var DEFAULT_RUNTIME_RENDER_CHECK = {
   id: "runtime-render",
   run: async (input) => {
     const { sourceCode, compiledCode, contract, fixtureProps } = input;
-    if (compiledCode === null) return [];
-    if (!contract) return [];
+    if (compiledCode === null) {
+      return { status: "not-applicable", issues: [], reason: "no compiled code" };
+    }
+    if (!contract) {
+      return { status: "not-applicable", issues: [], reason: "no contract surface" };
+    }
     const mockup = prepareMockupProps({ contract, fixtureProps });
     let result;
     try {
@@ -15472,9 +15519,12 @@ var DEFAULT_RUNTIME_RENDER_CHECK = {
       console.warn(
         `[runtime-render] probe skipped \u2014 infra failure: ${message}`
       );
-      return [];
+      return { status: "infra-skipped", issues: [], reason: message };
     }
-    return result.issues.map(toEvalIssue).filter((x) => x !== null);
+    return {
+      status: "ran",
+      issues: result.issues.map(toEvalIssue).filter((x) => x !== null)
+    };
   }
 };
 var CLASS_SPECIFIC_PATTERNS = [
@@ -15881,6 +15931,16 @@ async function executeTool(workspace, tool, input, commitMeta, contract, applyPa
           error: true
         };
       }
+      const gutterLine = normalizedChanges.flatMap((c) => c.code).find((l) => /^\s*\d+(?::[0-9a-f]{2})?│/.test(l));
+      if (gutterLine !== void 0) {
+        console.log(
+          `[coding-agent] apply_changes: GUTTER_TRANSCRIBED | ${JSON.stringify(gutterLine.slice(0, 60))}`
+        );
+        return {
+          result: `PATCH_INVALID: your \`code\` contains the line-number gutter from the Current File view (e.g. ${JSON.stringify(gutterLine.trim().slice(0, 40))}). The \`N\u2502\` prefix is display decoration \u2014 \`code\` must be raw file content only. Re-emit the patch without the gutter.`,
+          error: true
+        };
+      }
       const { defaultApplyPatch: defaultApplyPatch2 } = await Promise.resolve().then(() => (init_patch(), patch_exports));
       const patcher = applyPatch2 ?? defaultApplyPatch2;
       const patchResult = await patcher({
@@ -15956,6 +16016,16 @@ async function executeTool(workspace, tool, input, commitMeta, contract, applyPa
 
 Patch tag-balance imbalance: ${tagImbalanceSummary}
 (Net opens vs closes inside your edit ranges. If a tag has +N, you opened N more than you closed within the patch \u2014 verify each <Tag> has a matching </Tag> in your changes, or that the surrounding scaffold provides the closer.)` : "";
+        const contextAddendum = buildRangeContextAddendum(
+          errLine,
+          changes,
+          currentFile.split("\n")
+        );
+        if (contextAddendum.length > 0) {
+          console.log(
+            `[coding-agent] apply_changes: RANGE_CONTEXT_DIAG | line=${errLine} | ${JSON.stringify(contextAddendum.slice(0, 80))}`
+          );
+        }
         return {
           result: `${preflightPrefix}PATCH_APPLIED_BROKEN: patch applied but file has a syntax error. Workspace updated; no git commit yet.
 Changed ranges: ${ranges}
@@ -15964,7 +16034,7 @@ esbuild error: ${errText}${typeof errLine === "number" ? ` (line ${errLine}${typ
 ${sliceLabel}:
 ${slice}
 
-The file now reflects your latest patch. Submit a follow-up apply_changes targeting the error location above to converge toward a compilable file.${imbalanceHint}`,
+The file now reflects your latest patch. Submit a follow-up apply_changes targeting the error location above to converge toward a compilable file.${contextAddendum}${imbalanceHint}`,
           error: false
         };
       }
@@ -16059,9 +16129,42 @@ ${content}` };
       return { result: `Unknown tool: ${tool}`, error: true };
   }
 }
+function buildRangeContextAddendum(errLine, changes, originalLines) {
+  if (typeof errLine !== "number") return "";
+  const hit = changes.find((c) => c.startLine === errLine);
+  if (!hit) return "";
+  const firstPayloadLine = hit.code.find((l) => l.trim().length > 0) ?? "";
+  const declMatch = /^\s*(const|let|var|function|type|interface)\b/.exec(
+    firstPayloadLine
+  );
+  if (declMatch) {
+    for (let i = hit.startLine - 2; i >= 0; i--) {
+      const line = originalLines[i];
+      if (line === void 0 || line.trim().length === 0) continue;
+      if (/\breturn\s*\($/.test(line.trim())) {
+        return `
+
+Range/context mismatch: line ${i + 1} is \`return (\` \u2014 your range starts at ${hit.startLine}, INSIDE the returned JSX expression, but your payload begins with a declaration (\`${declMatch[1]}\`). Declarations cannot live inside JSX: start the range at or before line ${i + 1} and re-emit \`return (\` after them.`;
+      }
+      break;
+    }
+  }
+  if (hit.code.some((l) => l.includes("export default function"))) {
+    const existing = originalLines.findIndex(
+      (l) => l.includes("export default function")
+    );
+    if (existing >= 0 && existing + 1 < hit.startLine) {
+      return `
+
+Range/context mismatch: your payload emits a second \`export default function\` but the range starts at line ${hit.startLine}, INSIDE the existing component that opens at line ${existing + 1}. Patch within the existing function body \u2014 do not re-emit the component definition.`;
+    }
+  }
+  return "";
+}
 
 // src/harness/coding/run-coding-turn.ts
 init_hashline();
+init_dupe_break();
 function extractFailSignature(resultText) {
   const esbuildMatch = resultText.match(/esbuild error: ([^\n]+)/);
   if (esbuildMatch) return esbuildMatch[1];
@@ -16334,9 +16437,35 @@ ${closingInstruction}`;
       }
     }
     console.log(`[simple] turn ${turnsUsed}: get_available_icons`);
-    const iconResult = `Available Lucide icon names (use with <Icon name="...">):
+    let iconResult = `Available Lucide icon names (use with <Icon name="...">):
 ${iconNamesCache}`;
+    let iconRepeats = 0;
+    if (ctx.dupeBreak) {
+      iconRepeats = recordToolExchange(ctx.dupeBreak, call.name, call.input, iconResult);
+      if (iconRepeats === 2) iconResult += SAME_EXCHANGE_NUDGE;
+    }
     await codingAgent.sendToolResult([{ callId: call.id, name: call.name, result: iconResult }]);
+    if (iconRepeats >= SAME_EXCHANGE_BREAK_AT) {
+      console.log(
+        `[coding-agent] SAME_EXCHANGE_BREAK | tool=${call.name} | repeats=${iconRepeats} \u2014 terminating run (ggui#404)`
+      );
+      return {
+        control: "break",
+        compiledCode: "",
+        selfCheckPassed: false,
+        outcome: void 0,
+        phase: void 0,
+        tokens,
+        ...cacheTokens,
+        llmMs,
+        toolMs: 0,
+        lastResultText: iconResult,
+        lastDiffFailed: false,
+        isEvalFeedback: false,
+        iconNamesCache,
+        preWarmedContext
+      };
+    }
     return {
       control: "continue",
       compiledCode: "",
@@ -16488,12 +16617,45 @@ Repeated error: ${errText}
   } else if (ctx.dupeBreak && call.name === "rewrite") {
     if (!result.error) ctx.dupeBreak.consecutiveBrokenApplies = 0;
   }
+  let sameExchangeRepeats = 0;
+  if (ctx.dupeBreak) {
+    sameExchangeRepeats = recordToolExchange(
+      ctx.dupeBreak,
+      call.name,
+      call.input,
+      result.result
+    );
+    if (sameExchangeRepeats === 2) {
+      augmentedResultText += SAME_EXCHANGE_NUDGE;
+    }
+  }
   await codingAgent.sendToolResult([{
     callId: call.id,
     name: call.name,
     result: augmentedResultText,
     isError: !!result.error
   }]);
+  if (sameExchangeRepeats >= SAME_EXCHANGE_BREAK_AT) {
+    console.log(
+      `[coding-agent] SAME_EXCHANGE_BREAK | tool=${call.name} | repeats=${sameExchangeRepeats} \u2014 terminating run (ggui#404)`
+    );
+    return {
+      control: "break",
+      compiledCode: "",
+      selfCheckPassed: false,
+      outcome: void 0,
+      phase: void 0,
+      tokens,
+      ...cacheTokens,
+      llmMs,
+      toolMs,
+      lastResultText: augmentedResultText,
+      lastDiffFailed: false,
+      isEvalFeedback: false,
+      iconNamesCache,
+      preWarmedContext
+    };
+  }
   const turnDiffFailed = !!result.error && result.result.includes("DIFF");
   const isDiffFail = turnDiffFailed && !isPatchInvalid;
   const outcome = result.done ? "PASS" : isPatchInvalid ? "PATCH_INVALID" : isDiffFail ? "DIFF_FAIL" : "SELF_CHECK_FAIL";
@@ -16575,26 +16737,46 @@ async function runProbeAtExit(input) {
   const { harness, sourceCode, compiledCode, contract, fixtureProps } = input;
   const probe = harness.check.runtimeRender;
   if (!probe || !compiledCode) {
-    return { fired: false, recoverableFail: false, probeIssues: [] };
+    return {
+      fired: false,
+      recoverableFail: false,
+      probeIssues: [],
+      meta: {
+        status: "not-applicable",
+        reason: probe ? "no compiled code" : "no runtimeRender check configured"
+      }
+    };
   }
-  let probeIssues;
+  let outcome;
   try {
-    probeIssues = await probe.run({
+    outcome = await probe.run({
       sourceCode,
       compiledCode,
       contract,
       fixtureProps
     });
   } catch (e) {
-    console.warn(
-      `[simple] in-loop probe at exit: infra failure \u2014 ${e instanceof Error ? e.message : String(e)}`
-    );
-    return { fired: false, recoverableFail: false, probeIssues: [] };
+    const message = e instanceof Error ? e.message : String(e);
+    console.warn(`[simple] in-loop probe at exit: infra failure \u2014 ${message}`);
+    return {
+      fired: false,
+      recoverableFail: false,
+      probeIssues: [],
+      meta: { status: "infra-skipped", reason: message }
+    };
   }
+  const meta = {
+    status: outcome.status,
+    ...outcome.reason !== void 0 ? { reason: outcome.reason } : {}
+  };
+  if (outcome.status !== "ran") {
+    return { fired: false, recoverableFail: false, probeIssues: [], meta };
+  }
+  const probeIssues = outcome.issues;
   const recoverableFail = probeIssues.some(
     (i) => i.result === "fail" && typeof i.subcategory === "string" && i.subcategory.startsWith("runtime:render-no-throw") && typeof i.description === "string" && isRecoverableRenderCrash(i.description)
   );
-  return { fired: true, recoverableFail, probeIssues };
+  return { fired: true, recoverableFail, probeIssues, meta };
 }
 function formatRuntimeProbeFeedback(issue) {
   const subcat = issue.subcategory ? `/${issue.subcategory}` : "";
@@ -16656,7 +16838,7 @@ async function runEvalRound(ctx, input) {
         );
         const lines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
         const allIssues2 = [...modeIssues, ...exitProbe.probeIssues];
-        evalResult = { issues: allIssues2, pass: ["axis.low-risk"] };
+        evalResult = { issues: allIssues2, pass: ["axis.low-risk"], runtimeProbe: exitProbe.meta };
         console.log(
           `[simple] eval round ${evalRoundsUsed}: low-risk bypass clean BUT runtime probe fail (recoverable) \u2014 granting +1 turn`
         );
@@ -16677,10 +16859,11 @@ async function runEvalRound(ctx, input) {
       }
       evalResult = {
         issues: [...modeIssues, ...exitProbe.probeIssues],
-        pass: ["axis.low-risk"]
+        pass: ["axis.low-risk"],
+        runtimeProbe: exitProbe.meta
       };
       console.log(
-        `[simple] eval round ${evalRoundsUsed}: low-risk bypass (axis-checks clean, tier-1/2 skipped${exitProbe.fired ? ", probe ran" : ""}) \u2014 PASS`
+        `[simple] eval round ${evalRoundsUsed}: low-risk bypass (axis-checks clean, tier-1/2 skipped${exitProbe.fired ? ", probe ran" : `, probe ${exitProbe.meta.status}`}) \u2014 PASS`
       );
       return {
         control: "break",
@@ -16787,7 +16970,7 @@ async function runEvalRound(ctx, input) {
         );
         const lines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
         const enrichedIssues = [...allIssues, ...exitProbe.probeIssues];
-        evalResult = { issues: enrichedIssues, pass: allPass };
+        evalResult = { issues: enrichedIssues, pass: allPass, runtimeProbe: exitProbe.meta };
         const enrichedFingerprints = /* @__PURE__ */ new Set([
           ...currFailFingerprints,
           ...runtimeFails.map(fingerprintFail)
@@ -16810,12 +16993,11 @@ async function runEvalRound(ctx, input) {
           lastDiffFailed: false
         };
       }
-      if (exitProbe.fired && exitProbe.probeIssues.length > 0) {
-        evalResult = {
-          issues: [...allIssues, ...exitProbe.probeIssues],
-          pass: allPass
-        };
-      }
+      evalResult = {
+        issues: [...allIssues, ...exitProbe.probeIssues],
+        pass: allPass,
+        runtimeProbe: exitProbe.meta
+      };
       console.log(`[simple] eval round ${evalRoundsUsed}: no blocking issues \u2014 PASS`);
       return {
         control: "break",
@@ -16837,6 +17019,18 @@ async function runEvalRound(ctx, input) {
       console.log(
         `[simple] eval round ${evalRoundsUsed}: stuck \u2014 all ${currFailFingerprints.size} fails recur from prior round, exiting eval-fix loop`
       );
+      const stuckExitProbe = await runProbeAtExit({
+        harness,
+        sourceCode: currentSource,
+        compiledCode,
+        contract,
+        fixtureProps
+      });
+      evalResult = {
+        issues: [...evalResult.issues, ...stuckExitProbe.probeIssues],
+        pass: evalResult.pass,
+        runtimeProbe: stuckExitProbe.meta
+      };
       return {
         control: "break",
         evalDone: false,
@@ -16864,12 +17058,11 @@ async function runEvalRound(ctx, input) {
       const hasRuntimeFail = exitProbe.fired && exitProbe.recoverableFail;
       const allowRuntimeExtension = hasRuntimeFail && evalRoundsUsed < maxEvalRounds + RUNTIME_EXTENSION_BONUS;
       if (!allowRuntimeExtension) {
-        if (exitProbe.fired && exitProbe.probeIssues.length > 0) {
-          evalResult = {
-            issues: [...evalResult.issues, ...exitProbe.probeIssues],
-            pass: evalResult.pass
-          };
-        }
+        evalResult = {
+          issues: [...evalResult.issues, ...exitProbe.probeIssues],
+          pass: evalResult.pass,
+          runtimeProbe: exitProbe.meta
+        };
         console.log(`[simple] eval round ${evalRoundsUsed}: max eval rounds reached \u2014 stopping`);
         return {
           control: "break",
@@ -16891,7 +17084,7 @@ async function runEvalRound(ctx, input) {
       );
       const probeLines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
       const enrichedIssues = [...evalResult.issues, ...exitProbe.probeIssues];
-      evalResult = { issues: enrichedIssues, pass: evalResult.pass };
+      evalResult = { issues: enrichedIssues, pass: evalResult.pass, runtimeProbe: exitProbe.meta };
       console.log(
         `[simple] eval round ${evalRoundsUsed}: runtime-probe fail active at cap \u2014 granting +1 retry (${maxEvalRounds + RUNTIME_EXTENSION_BONUS - evalRoundsUsed} of ${RUNTIME_EXTENSION_BONUS} bonus rounds remain)`
       );