@ggui-ai/ui-gen 0.28.0 → 0.29.0

package/dist/chunk-R5GIGPW2.js

@@ -0,0 +1,2845 @@
+import { createDupeBreakState, recordToolExchange, SAME_EXCHANGE_NUDGE, SAME_EXCHANGE_BREAK_AT, clearWriteFailures, recordWriteFailure, SAME_FAILURE_NUDGE_AT, SAME_FAILURE_BREAK_AT, SAME_FAILURE_NUDGE } from './chunk-RH4IUSTO.js';
+import { resolveHarnessPolicy } from './chunk-5VBXHVEH.js';
+import { formatWithHashlines } from './chunk-4MBR5GA3.js';
+import { buildSystemPrompt } from './chunk-5EJM7EGY.js';
+import { PRIMITIVES_DOCUMENTATION } from './chunk-HD6ABIK7.js';
+import { createHarness, runHarness, APPLY_CHANGES_TOOL, GET_ICONS_TOOL, APPLY_CHANGES_TOOL_SCOPED, ICON_LIST_NO_MATCH_GUIDANCE, runCheck, REWRITE_TOOL, WRITE_PLAN_TOOL, GET_COMPONENTS_INFO_TOOL, APPLY_CHANGES_HASHLINE_TOOL_FLAT, APPLY_CHANGES_HASHLINE_TOOL, APPLY_CHANGES_TOOL_FLAT } from './chunk-WEOXFEVE.js';
+import { runTier0Checks } from './chunk-FWJIMKFZ.js';
+import { classifyAxes } from './chunk-5KXCQLLR.js';
+import { criteriaContextFor } from './chunk-DXKRBXNU.js';
+import { createAgent } from './chunk-O2YC6XDC.js';
+import { traceAxisChecksSkipped, runGatedAxisChecks } from './chunk-U7GALWLG.js';
+import { REGISTRY } from './chunk-GYINWMPR.js';
+import { warmupRuntimeRenderProbe, DEFAULT_RUNTIME_RENDER_CHECK, isRecoverableRenderCrash, parseRuntimeSubcategory } from './chunk-BA4QYA6E.js';
+import { RENDER_CHECK_KINDS } from './chunk-3NNNGNTO.js';
+import { restoreReactImport } from './chunk-Z3CXME3K.js';
+import { matches, getActionableIssues, notApplicableCoverage } from './chunk-PUH4CXGZ.js';
+import { canvasForRendering, DEFAULT_DESIGN_MODE } from './chunk-3T2HMTON.js';
+import { DEFAULT_HARNESS_POLICY } from './chunk-JMD4RGSV.js';
+import * as esbuild from 'esbuild';
+import { LUCIDE_ICON_NAMES } from '@ggui-ai/design';
+import { listContractGadgets } from '@ggui-ai/protocol';
+import git from 'isomorphic-git';
+import { Volume, createFsFromVolume } from 'memfs';
+import { createPatch, applyPatch } from 'diff';
+
+// src/harness/coding/assemble-result.ts
+async function assembleGenerationResult(input) {
+  const { session, telemetry, source } = input;
+  const a1Mode = session.harness.process.mode === "staged";
+  let needsBackgroundImprovement = false;
+  if (session.qualityMode === "auto-improve" && telemetry.evalResult && session.tiersMod) {
+    const remaining = getActionableIssues(
+      telemetry.evalResult,
+      "high-quality"
+    );
+    if (remaining.length > 0) {
+      needsBackgroundImprovement = true;
+      console.log(
+        `[simple] auto-improve: ${remaining.length} remaining issues \u2192 background improvement needed`
+      );
+    }
+  }
+  const totalMs = Date.now() - session.startedAtMs;
+  const evalWallMs = telemetry.cumulativeEvalWallMs;
+  const codingOnlyMs = Math.max(0, telemetry.codingMs - evalWallMs);
+  const setupMs = Math.max(0, totalMs - telemetry.codingMs);
+  const timing = {
+    codingMs: codingOnlyMs,
+    evalMs: evalWallMs,
+    setupMs,
+    totalMs
+  };
+  await session.codingAgent.cleanup();
+  console.log(
+    `[simple] timing: coding=${codingOnlyMs}ms eval=${evalWallMs}ms setup=${setupMs}ms total=${totalMs}ms`
+  );
+  console.log(
+    `[simple] DONE | ${totalMs}ms | turns=${telemetry.turnsUsed} | evalRounds=${telemetry.evalRoundsUsed} | tokens=${telemetry.totalIn + telemetry.totalOut} | compiled=${telemetry.compiledCode.length}B`
+  );
+  const { phases, outcomes } = telemetry.counters;
+  console.log(
+    `[simple] SUMMARY | turns=${telemetry.turnsUsed} impl=${phases.impl} patch=${phases.patch} evalFix=${phases.evalFix}` + (a1Mode ? ` scaffold=${phases.scaffold} fill=${phases.fill}` : "") + ` | pass=${outcomes.pass} patchInvalid=${outcomes.patchInvalid} selfCheckFail=${outcomes.selfCheckFail} diffFail=${outcomes.diffFail} | evalRounds=${telemetry.evalRoundsUsed} | codingLlmMs=${telemetry.cumulativeLlmMs} evalLlmMs=${telemetry.cumulativeEvalLlmMs} toolMs=${telemetry.cumulativeToolMs} evalWallMs=${evalWallMs}`
+  );
+  return {
+    compiledCode: telemetry.compiledCode,
+    sourceCode: source,
+    tokens: {
+      input: telemetry.totalIn,
+      output: telemetry.totalOut,
+      // ggui#1186: the FULL processed footprint — the adapters' convention
+      // (non-cached input + cache creation + cache reads + output) — so a
+      // row's cached count is `total − input − output` even where the cache
+      // fields are not published. `input + output` alone priced the cached
+      // prefix and hid it (a 36k-token luna turn published as 1.6k).
+      total: telemetry.totalIn + (telemetry.cacheCreationTokens ?? 0) + (telemetry.cacheReadTokens ?? 0) + telemetry.totalOut
+    },
+    // Prompt-cache counters are provider-specific — pass through truthfully.
+    // Absent on the telemetry (provider didn't report) stays absent here,
+    // never defaulted to 0, so the downstream observability ratio reflects
+    // real cache activity instead of a structural zero.
+    ...telemetry.cacheReadTokens !== void 0 ? { cacheReadTokens: telemetry.cacheReadTokens } : {},
+    ...telemetry.cacheCreationTokens !== void 0 ? { cacheCreationTokens: telemetry.cacheCreationTokens } : {},
+    // ggui#1522 — the in-loop visual judge's spend, beside `tokens` and never inside it.
+    ...telemetry.inLoopVisualTokens !== void 0 ? { inLoopVisualTokens: telemetry.inLoopVisualTokens } : {},
+    generationTimeMs: totalMs,
+    turnsUsed: telemetry.turnsUsed,
+    passesUsed: 1,
+    // ggui#1261 — the contract-feedback round's record rides the result the
+    // generation ends with (whose probe stamp is the post-round verdict).
+    evalResult: telemetry.evalResult !== void 0 && telemetry.contractFeedback !== void 0 ? { ...telemetry.evalResult, contractFeedback: telemetry.contractFeedback } : telemetry.evalResult,
+    // ggui#404 — present only when the same-exchange guard ended the run.
+    ...telemetry.sameExchangeBreak !== void 0 ? { sameExchangeBreak: telemetry.sameExchangeBreak } : {},
+    ...telemetry.sameFailureBreak !== void 0 ? { sameFailureBreak: telemetry.sameFailureBreak } : {},
+    needsBackgroundImprovement,
+    selfCheckPassed: telemetry.selfCheckPassed,
+    timing,
+    breakdown: {
+      phases: { ...phases },
+      outcomes: { ...outcomes },
+      evalRounds: telemetry.evalRoundsUsed,
+      // `llmMs` retained as coding-turn LLM (stable semantics for existing
+      // consumers in benchmarks/multi-sdk/runner.ts:312); `evalLlmMs` is
+      // new, covers eval-round parallel LLM+visual wall-time.
+      llmMs: telemetry.cumulativeLlmMs,
+      evalLlmMs: telemetry.cumulativeEvalLlmMs,
+      toolMs: telemetry.cumulativeToolMs,
+      evalMs: evalWallMs,
+      codingMs: codingOnlyMs,
+      setupMs
+    }
+  };
+}
+
+// src/coding-agent/self-check.ts
+function getSoftWarnings(code) {
+  const warnings = [];
+  if (!/var\(--ggui-/.test(code)) {
+    warnings.push(
+      "uses_design_tokens: No CSS variables (var(--ggui-*)) found \u2014 consider using design system tokens"
+    );
+  }
+  if (!/aria-label/.test(code)) {
+    warnings.push(
+      "has_aria_labels: No aria-label attributes found \u2014 consider adding for accessibility"
+    );
+  }
+  return warnings;
+}
+
+// src/coding-agent/tools.ts
+function axisCountsWithIds(issues) {
+  const idOf = (i) => 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(" ")}]` : ""}`;
+}
+function getComponentDocumentation(name) {
+  const marker = `### ${name}`;
+  const startIdx = PRIMITIVES_DOCUMENTATION.indexOf(marker);
+  if (startIdx === -1) {
+    return `Component "${name}" not found. Available primitives: Container, Card, Stack, Row, Box, Text, Heading, Button, Input, Select, Checkbox, Toggle, Badge, Alert, Progress, Image, Icon, Divider, Tabs, Accordion, Table, Tooltip, Spinner, Avatar, Link`;
+  }
+  const nextMarker = PRIMITIVES_DOCUMENTATION.indexOf("### ", startIdx + marker.length);
+  const section = nextMarker === -1 ? PRIMITIVES_DOCUMENTATION.slice(startIdx) : PRIMITIVES_DOCUMENTATION.slice(startIdx, nextMarker);
+  return section.replace(/\\n/g, "\n").replace(/\\"/g, '"').slice(0, 3e3);
+}
+async function autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode = DEFAULT_DESIGN_MODE, axis) {
+  const commitStart = Date.now();
+  const raw = workspace.read();
+  if (!raw && raw !== "") {
+    return { result: "FAILED: no file to compile", error: true };
+  }
+  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;
+  const buildStart = Date.now();
+  let buildSuccess = false;
+  let compiledCode = "";
+  const buildErrors = [];
+  try {
+    const result = await esbuild.transform(formatted, {
+      loader: "tsx",
+      target: "es2020",
+      format: "esm",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      minify: true,
+      keepNames: true
+    });
+    compiledCode = result.code;
+    buildSuccess = true;
+  } catch (e) {
+    buildErrors.push(e instanceof Error ? e.message : String(e));
+  }
+  const buildMs = Date.now() - buildStart;
+  const buildResult = {
+    success: buildSuccess,
+    compiledCode: buildSuccess ? compiledCode : void 0,
+    errors: buildErrors.length > 0 ? buildErrors : void 0
+  };
+  const selfCheckStart = Date.now();
+  const tier0Issues = await runTier0Checks(
+    formatted,
+    contract,
+    buildResult.errors,
+    gadgetTypes,
+    designMode
+  );
+  const axisFacts = axis !== void 0 ? {
+    sourceCode: formatted,
+    ...contract !== void 0 ? { contract } : {},
+    originalPrompt: axis.originalPrompt,
+    classification: axis.classification,
+    designMode,
+    ...axis.canvas !== void 0 ? { canvas: axis.canvas } : {},
+    ...axis.fixtureProps !== void 0 ? { fixtureProps: axis.fixtureProps } : {}
+  } : void 0;
+  if (axisFacts !== void 0 && !buildSuccess) traceAxisChecksSkipped(axisFacts, "build failed \u2014 no check ran");
+  const axisRun = axis !== void 0 && axisFacts !== void 0 && buildSuccess ? runGatedAxisChecks(axis.checks, { ...axisFacts, compiledCode }) : void 0;
+  const axisIssues = axisRun?.issues ?? [];
+  const checkIssues = [...tier0Issues, ...axisIssues];
+  const tier0Fails = checkIssues.filter((i) => i.result === "fail");
+  const selfCheckPassed = tier0Fails.length === 0;
+  const violations = checkIssues.filter((i) => i.result === "fail").map((i) => contextPolicy?.labeledTier0 ? `[${i.priority ?? "P0"}-${i.category}] ${i.description}
+  Fix: ${i.fix}` : `[${i.category}] ${i.description}
+  Fix: ${i.fix}`);
+  const axisWarnings = axisIssues.filter((i) => i.result === "warn").map((i) => `[${i.subcategory}] ${i.description} Fix: ${i.fix}`);
+  const softWarnings = [...getSoftWarnings(raw), ...axisWarnings];
+  const selfCheckMs = Date.now() - selfCheckStart;
+  const gitStart = Date.now();
+  const oid = await workspace.commit(message);
+  commitMeta.set(oid, { build: buildResult, selfCheck: { passed: selfCheckPassed, violations } });
+  const gitMs = Date.now() - gitStart;
+  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 === void 0 ? "off" : axisCountsWithIds(axisIssues)}`
+  );
+  if (violations.length > 0) {
+    for (const v of violations) {
+      console.log(`[coding-agent]   \u2717 ${v}`);
+    }
+  }
+  if (buildSuccess && selfCheckPassed) {
+    const warnStr = softWarnings.length > 0 ? `
+Warnings (non-blocking): ${softWarnings.join("; ")}` : "";
+    return {
+      result: `Committed ${oid.slice(0, 7)}: "${message}"
+Build: OK
+Self-check: PASS${warnStr}`,
+      done: true,
+      compiledCode
+    };
+  }
+  const errors = [
+    ...buildErrors.length > 0 ? [`Build errors:
+${buildErrors.join("\n")}`] : [],
+    ...!selfCheckPassed ? [`Self-check violations:
+${violations.join("\n")}`] : []
+  ];
+  return {
+    result: `Committed ${oid.slice(0, 7)}: "${message}"
+${errors.join("\n")}
+Fix the issues.`
+  };
+}
+async function executeTool(workspace, tool, input, commitMeta, contract, applyPatch2, contextPolicy, gadgetTypes, designMode = DEFAULT_DESIGN_MODE, axis) {
+  switch (tool) {
+    case "write":
+    case "rewrite": {
+      const code = input.code;
+      if (!code && code !== "") {
+        console.warn(
+          `[coding-agent] write: no "code" field. Keys: [${Object.keys(input).join(", ")}]`
+        );
+        return {
+          result: `FAILED: write requires a "code" field. Received: [${Object.keys(input).join(", ")}]`,
+          error: true
+        };
+      }
+      workspace.write(code);
+      await workspace.stage();
+      const lineCount = code.split("\n").length;
+      const message = input.commit_message || `write ${lineCount} lines`;
+      console.log(`[coding-agent] write: ${lineCount} lines \u2192 auto-commit`);
+      return autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode, axis);
+    }
+    case "apply_changes": {
+      const currentFile = workspace.read();
+      if (!currentFile && currentFile !== "") {
+        return { result: "FAILED: No file exists.", error: true };
+      }
+      const inputChanges = input.changes;
+      const rawChanges = inputChanges ? Array.isArray(inputChanges) ? inputChanges : [inputChanges] : [];
+      const allowBroken = input.allowBroken === true;
+      const { parseHashlineRef, validateHashlineRefs, formatHashlineStaleMessage } = await import('./hashline-5OKREIRM.js');
+      const normalizedChanges = [];
+      for (let i = 0; i < (rawChanges ?? []).length; i++) {
+        const c = rawChanges[i];
+        let startLine;
+        let expectedStartHash;
+        if (typeof c.startLine === "string") {
+          const parsed = parseHashlineRef(c.startLine);
+          if (!parsed) {
+            return {
+              result: `FAILED: change[${i}].startLine = ${JSON.stringify(c.startLine)} is not a valid hashline ref (expected "N:hh" format).`,
+              error: true
+            };
+          }
+          startLine = parsed.line;
+          expectedStartHash = parsed.expectedHash;
+        } else {
+          startLine = c.startLine;
+        }
+        let endLine;
+        let expectedEndHash;
+        if (typeof c.endLine === "string") {
+          const parsed = parseHashlineRef(c.endLine);
+          if (!parsed) {
+            return {
+              result: `FAILED: change[${i}].endLine = ${JSON.stringify(c.endLine)} is not a valid hashline ref (expected "N:hh" format).`,
+              error: true
+            };
+          }
+          endLine = parsed.line;
+          expectedEndHash = parsed.expectedHash;
+        } else {
+          endLine = c.endLine;
+        }
+        normalizedChanges.push({
+          startLine,
+          endLine,
+          code: Array.isArray(c.code) ? c.code : typeof c.code === "string" ? c.code.split("\n") : [],
+          description: c.description ?? `change ${i + 1}`,
+          expectedStartHash,
+          expectedEndHash
+        });
+      }
+      const hashlineIssues = validateHashlineRefs(currentFile, normalizedChanges);
+      if (hashlineIssues.length > 0) {
+        const ranges = normalizedChanges.map((c) => `${c.startLine}-${c.endLine}`).join(", ");
+        console.log(
+          `[coding-agent] apply_changes: HASHLINE_STALE | ranges=${ranges} | ${hashlineIssues.length} mismatch(es)`
+        );
+        return {
+          result: formatHashlineStaleMessage(hashlineIssues),
+          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 } = await import('./patch.js');
+      const patcher = applyPatch2 ?? defaultApplyPatch;
+      const patchResult = await patcher({
+        sourceBefore: currentFile,
+        changes: normalizedChanges
+      });
+      if (!patchResult.ok) {
+        console.log(`[coding-agent] apply_changes: REJECTED | ${patchResult.error}`);
+        return { result: `PATCH_INVALID: ${patchResult.error}`, error: true };
+      }
+      const candidate = patchResult.sourceAfter ?? currentFile;
+      const changes = [...normalizedChanges].sort((a, b) => a.startLine - b.startLine);
+      for (const c of changes) {
+        console.log(
+          `[coding-agent] change: lines ${c.startLine}-${c.endLine} \u2192 ${c.code.length} lines | ${c.description}`
+        );
+      }
+      const resultLines = candidate.split("\n");
+      let tagImbalanceSummary = null;
+      {
+        const { checkPatchTagBalance } = await import('./tag-balance-CTHCTRJ7.js');
+        const imbalance = checkPatchTagBalance(currentFile, changes);
+        if (imbalance.imbalanced) {
+          const ranges = changes.map((c) => `${c.startLine}-${c.endLine}`).join(", ");
+          const totalsSummary = imbalance.totals.map((d) => `${d.tag}${d.netDelta >= 0 ? "+" : ""}${d.netDelta}`).join(" ");
+          console.log(
+            `[coding-agent] apply_changes: tag-balance-diag | ranges=${ranges} | ${totalsSummary}`
+          );
+          tagImbalanceSummary = totalsSummary;
+        }
+      }
+      try {
+        await esbuild.transform(candidate, {
+          loader: "tsx",
+          target: "es2020",
+          format: "esm",
+          jsx: "automatic",
+          jsxImportSource: "react",
+          minify: true,
+          keepNames: true
+        });
+      } catch (e) {
+        const errMsg = e instanceof Error ? e.message : String(e);
+        const esErrs = e.errors ?? [];
+        const firstErr = esErrs[0];
+        const errLine = firstErr?.location?.line;
+        const errCol = firstErr?.location?.column;
+        const errText = firstErr?.text ?? errMsg.split("\n")[0];
+        const ranges = changes.map((c) => `${c.startLine}-${c.endLine}`).join(", ");
+        let sliceStart;
+        let sliceEnd;
+        let sliceLabel;
+        if (typeof errLine === "number" && errLine > 0) {
+          sliceStart = Math.max(0, errLine - 6);
+          sliceEnd = Math.min(resultLines.length, errLine + 5);
+          sliceLabel = `Candidate slice (\xB15 lines around esbuild error at line ${errLine}${typeof errCol === "number" ? `:${errCol}` : ""})`;
+        } else {
+          const first = changes[0];
+          sliceStart = Math.max(0, first.startLine - 6);
+          sliceEnd = Math.min(resultLines.length, first.endLine + 5);
+          sliceLabel = `Candidate slice (around first changed range)`;
+        }
+        const slice = resultLines.slice(sliceStart, sliceEnd).map((l, i) => {
+          const lineNum = sliceStart + i + 1;
+          const marker = lineNum === errLine ? " \u25C4\u2500\u2500 esbuild error here" : "";
+          return `${lineNum}\u2502${l}${marker}`;
+        }).join("\n");
+        workspace.write(candidate);
+        console.log(
+          `[coding-agent] apply_changes: APPLIED-BROKEN (preflight failed)${allowBroken ? " [allowBroken]" : ""} | ranges=${ranges} | line=${errLine ?? "?"} | ${errText}`
+        );
+        const preflightPrefix = contextPolicy?.labeledPreflight ? `[P0-compile] ` : ``;
+        const imbalanceHint = tagImbalanceSummary ? `
+
+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}
+esbuild error: ${errText}${typeof errLine === "number" ? ` (line ${errLine}${typeof errCol === "number" ? `, col ${errCol}` : ""})` : ""}
+
+${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.${contextAddendum}${imbalanceHint}`,
+          error: false
+        };
+      }
+      workspace.write(candidate);
+      await workspace.stage();
+      const message = input.commit_message || "apply changes";
+      console.log(`[coding-agent] apply_changes: ${changes.length} changes applied \u2192 auto-commit`);
+      return autoCommit(workspace, commitMeta, message, contract, contextPolicy, gadgetTypes, designMode, axis);
+    }
+    case "get_components_info": {
+      const names = input.names ?? [];
+      const docs = names.map((name) => getComponentDocumentation(name));
+      return { result: docs.join("\n\n---\n\n") };
+    }
+    case "write_plan": {
+      const components = input.components ?? [];
+      const structure = input.structure ?? "";
+      const wiring = input.wiring ?? "";
+      const summary = `PLAN_COMMITTED
+
+Components: ${components.join(", ")}
+
+Structure: ${structure}
+
+Wiring: ${wiring}
+
+On the next turn, use apply_changes to write the code. Fetch more component docs only if needed.`;
+      return { result: summary };
+    }
+    // `cat` is NOT advertised on the bench's coding-turn tool list —
+    // `run-coding-turn.ts::selectTurnTools` omits it because every turn's
+    // prompt already injects the current file as a `## Current File`
+    // block, so no read-tool is needed there. The case stays for
+    // dev-agent workflows that don't auto-inject file content.
+    case "cat":
+      return {
+        result: workspace.cat(
+          input.start_line,
+          input.end_line
+        )
+      };
+    case "grep":
+      return {
+        result: workspace.grep(
+          input.pattern,
+          input.context
+        )
+      };
+    case "diff":
+      return { result: await workspace.diffWorking() };
+    case "log": {
+      const commits = await workspace.log(input.depth);
+      if (commits.length === 0) return { result: "(no commits)" };
+      const lines = commits.map((c) => {
+        const meta = commitMeta.get(c.oid);
+        const status = meta?.selfCheck.passed ? "PASS" : meta?.selfCheck ? "FAIL" : "\u2014";
+        return `${c.oid.slice(0, 7)} [${status}] ${c.commit.message.trim()}`;
+      });
+      return { result: lines.join("\n") };
+    }
+    case "show": {
+      const oidPrefix = input.oid;
+      const commits = await workspace.log();
+      const idx = commits.findIndex((c) => c.oid.startsWith(oidPrefix));
+      if (idx === -1) {
+        return { result: `Commit not found: ${oidPrefix}`, error: true };
+      }
+      const thisOid = commits[idx].oid;
+      const parentOid = idx + 1 < commits.length ? commits[idx + 1].oid : null;
+      if (!parentOid) {
+        const content = await workspace.readFileAtCommit(thisOid);
+        return { result: `(initial commit)
+${content}` };
+      }
+      return { result: await workspace.diffBetween(parentOid, thisOid) };
+    }
+    case "revert": {
+      const oidPrefix = input.oid;
+      const commits = await workspace.log();
+      const match = commits.find((c) => c.oid.startsWith(oidPrefix));
+      if (!match) {
+        const available = commits.map((c) => c.oid.slice(0, 7)).join(", ");
+        return {
+          result: `OID not found: ${oidPrefix}. Available: ${available || "(none)"}`,
+          error: true
+        };
+      }
+      await workspace.checkout(match.oid);
+      return { result: `Reverted working copy to ${match.oid.slice(0, 7)}` };
+    }
+    default:
+      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 "";
+}
+function extractFailSignature(resultText) {
+  const esbuildMatch = resultText.match(/esbuild error: ([^\n]+)/);
+  if (esbuildMatch) return esbuildMatch[1];
+  const violationMatch = resultText.match(/^\[[A-Z][^\]]*\] [^\n]+/m);
+  if (violationMatch) return violationMatch[0];
+  const buildErrMatch = resultText.match(/Build errors:\s*\n([^\n]+)/);
+  if (buildErrMatch) return buildErrMatch[1];
+  return "";
+}
+function selectTurnTools(turnsUsed, forceEscape = false, consecutiveBrokenApplies = 0, hashlineMode = "off", primitiveIndexMode = "off", primitiveIndexForceFetch = false, primitiveIndexPlanTurn = false, planFirstTurn = false, codeFormat = "array") {
+  if (forceEscape) return [APPLY_CHANGES_TOOL_SCOPED];
+  if (consecutiveBrokenApplies >= 3) return [REWRITE_TOOL];
+  if (planFirstTurn && turnsUsed === 1) {
+    return [WRITE_PLAN_TOOL];
+  }
+  if (primitiveIndexForceFetch && primitiveIndexMode !== "off" && turnsUsed === 1) {
+    return [GET_COMPONENTS_INFO_TOOL];
+  }
+  if (primitiveIndexPlanTurn && primitiveIndexMode !== "off" && turnsUsed === 2) {
+    return [WRITE_PLAN_TOOL];
+  }
+  const applyTool = hashlineMode === "v2" ? codeFormat === "flat" ? APPLY_CHANGES_HASHLINE_TOOL_FLAT : APPLY_CHANGES_HASHLINE_TOOL : codeFormat === "flat" ? APPLY_CHANGES_TOOL_FLAT : APPLY_CHANGES_TOOL;
+  const tools = [applyTool, GET_ICONS_TOOL];
+  if (primitiveIndexMode !== "off") tools.push(GET_COMPONENTS_INFO_TOOL);
+  return tools;
+}
+async function runCodingTurn(ctx, input) {
+  const {
+    workspace,
+    codingAgent,
+    codingModel,
+    systemPrompt,
+    harness,
+    contract,
+    commitMeta,
+    originalProps,
+    costTracker
+  } = ctx;
+  const {
+    turnsUsed,
+    a1Phase,
+    lastResultText,
+    lastDiffFailed,
+    isEvalFeedback
+  } = input;
+  let { iconNamesCache, preWarmedContext } = input;
+  if (originalProps) {
+    const current = workspace.read() ?? "";
+    const currentProps = current.match(/interface Props \{[\s\S]*?\n\}/)?.[0];
+    if (currentProps && currentProps !== originalProps) {
+      workspace.write(current.replace(currentProps, originalProps));
+      await workspace.stage();
+    }
+  }
+  const hashlineMode = ctx.contextPolicy?.hashline ?? "off";
+  const currentFile = hashlineMode === "v2" ? formatWithHashlines(workspace.read() ?? "") : workspace.cat();
+  let userPrompt;
+  if (a1Phase === "scaffold") {
+    userPrompt = `Produce a COMPILEABLE structural first pass. This is turn 1 of 2 \u2014 you are NOT implementing the feature yet.
+
+## Required this turn (non-negotiable)
+
+1. Declare all hooks from the boilerplate: \`useState\` for local state you'll need, plus every \`useAction\` / \`useStream\` / \`useGguiContext\` from the contract, plus any capability hooks declared in \`clientCapabilities\` (from \`@ggui-ai/gadgets\`)
+2. Build a minimal valid JSX skeleton \u2014 one top-level \`<Container>\` or \`<Card>\` with a \`<Stack>\` of empty-but-valid region containers (one per logical section of the UI)
+3. Keep the \`export default function\` signature + \`Props\` interface exactly as in the boilerplate
+
+## NOT required yet (next turn will fill these in)
+
+- Rendering prop values or real content
+- Wiring hook callbacks to UI elements (empty \`onClick={() => {}}\` is fine)
+- Styling polish, icons, badges, variants
+- Interactive flows and derived state
+
+**Goal: compile + pass syntactic checks. Broken JSX wastes the whole round-trip \u2014 keep it minimal and valid.**
+
+## Current File
+\`\`\`tsx
+${currentFile}
+\`\`\``;
+  } else if (a1Phase === "fill") {
+    userPrompt = `The scaffold compiled. Now FILL in the details against the compiled skeleton. Make minimal, targeted patches \u2014 don't rewrite the whole file.
+
+## Required this turn (non-negotiable)
+
+1. Render every required prop from the Props interface in the appropriate region
+2. Wire every hook to a real interactive element with the correct payload shape
+3. Add real content \u2014 text, labels, icons, variants \u2014 so the UI matches the user's request
+
+## Allowed to simplify (ONLY flourishes/polish)
+
+- Elaborate animations \u2192 plain CSS transitions or static styles
+- Rare empty states \u2192 skip the branch
+- Fancy layout refinements \u2192 simpler grid/stack
+
+**Preserve the scaffolded region containers wherever possible.** Patch surgically inside them instead of rewriting the tree. Broken JSX or type errors waste a whole round-trip.
+
+## Current File (scaffolded, compiles)
+\`\`\`tsx
+${currentFile}
+\`\`\``;
+  } else if (turnsUsed === 1) {
+    userPrompt = `Deliver a compileable, end-to-end first pass in one turn.
+
+## Required this turn (non-negotiable)
+
+1. JSX structure that parses \u2014 balanced tags, closed fragments, no stray braces
+2. Render every required prop from the Props interface
+3. Wire every \`useAction\` / \`useStream\` / \`useGguiContext\` hook from the boilerplate to a visible element. If the contract declared \`clientCapabilities\`, the boilerplate emits a capability-hook call for each (e.g., \`const loc = useGeolocation();\`); call \`.start()\` from a UI control and render the result.
+
+## Allowed to simplify (ONLY flourishes/polish \u2014 NOT core work above)
+
+- Elaborate animations \u2192 plain CSS transitions or static styles
+- Rare empty states \u2192 skip the branch entirely
+- Fancy layout refinements \u2192 simpler grid/stack
+
+**If a flourish risks broken JSX or type errors, OMIT it rather than leaving a placeholder or partial structure.** No TODOs, no half-finished helpers, no stub components. Broken syntax or missing core work wastes a whole round-trip.
+
+Read the boilerplate comments \u2014 each hook has its type and call signature inline. Follow P0 \u2192 P1 \u2192 P2 priority from the system prompt.
+
+## Current File
+\`\`\`tsx
+${currentFile}
+\`\`\``;
+  } else {
+    const issues = lastResultText;
+    const diffHint = lastDiffFailed ? `
+**Your last diff did not apply.** Make sure context lines match the current file exactly. Use 3 lines of context around each change.
+` : "";
+    if (!preWarmedContext && input.preWarmPromise) {
+      preWarmedContext = await Promise.race([
+        input.preWarmPromise,
+        new Promise((r) => setTimeout(r, 0, null))
+      ]);
+    }
+    const issueHeader = isEvalFeedback ? "## Evaluation Issues (fix all)" : "## Issues (fix all)";
+    if (ctx.dupeBreak?.pendingDiagnosticTurn) {
+      ctx.dupeBreak.pendingDiagnosticTurn = false;
+      ctx.dupeBreak.awaitingDiagnosticOutcome = true;
+      const recents = ctx.dupeBreak.recentFailedPatches;
+      const head = recents[0];
+      const lines = currentFile.split("\n");
+      const firstRange = head?.rangesShort.split(",")[0]?.trim() ?? "";
+      const m = /^(\d+)-(\d+)$/.exec(firstRange);
+      const focusStart = m ? Math.max(1, parseInt(m[1], 10) - 15) : 1;
+      const focusEnd = m ? Math.min(lines.length, parseInt(m[2], 10) + 15) : lines.length;
+      const numbered = lines.slice(focusStart - 1, focusEnd).map((line, i) => `${String(focusStart + i).padStart(4, "0")}: ${line}`).join("\n");
+      const priorBlock = recents.map(
+        (p, i) => `  Attempt ${recents.length - i}: ranges=[${p.rangesShort}] error="${p.errClass}" fp=${p.fingerprint.slice(0, 12)}`
+      ).join("\n");
+      const promptPolicy = ctx.contextPolicy ?? harness.policy.context;
+      const noForce = promptPolicy.dupeBreakAction === "diagnostic-noforce";
+      const step2 = noForce ? `2. Then call \`apply_changes\`. The information above (line numbers + prior fingerprints) should let you see exactly what's wrong. If your patch turns out to be the same one you tried before, that's fine \u2014 but make sure you've verified line-by-line against the focused excerpt that the patch is actually correct.` : `2. Then call \`apply_changes\` with a patch that **differs materially** from your prior failed attempt \u2014 different ranges OR meaningfully different code at the same range. Re-emitting the same patch is not allowed.`;
+      userPrompt = `[LOOP DETECTED] Your last patch was byte-identical to a prior failed patch and produced the same preflight error. You are stuck in a fixed point \u2014 apply_changes alone won't escape this loop unless you re-examine the file.
+
+## Prior failed attempts (most recent first)
+${priorBlock}
+
+## Failing region \u2014 focused excerpt (lines ${focusStart}\u2013${focusEnd}, line-numbered)
+\`\`\`tsx
+${numbered}
+\`\`\`
+
+## What to emit on this turn
+
+1. Set \`commit_message\` to a one-line structured diagnosis in this exact format:
+   \`DIAG: why=<why the prior patch failed, \u226480 chars> | next=<what you will change instead, \u226480 chars> | lines=<startLine-endLine you will target>\`
+${step2}
+
+## Issues from prior turn (full text \u2014 for context)
+${issues}
+`;
+    } else {
+      const batchFixForced = typeof process !== "undefined" && process.env?.GGUI_BATCH_FIX === "on";
+      const closingInstruction = batchFixForced ? `**Fix EVERY error listed above in THIS single \`apply_changes\` call.** Emit multiple \`changes[]\` entries \u2014 one per range.` : `Produce ONE \`apply_changes\` call targeting only the lines that need fixing.`;
+      userPrompt = `Fix the issues below. Make **minimal, targeted changes** \u2014 do NOT rewrite the whole file.${diffHint}
+
+${issueHeader}
+${issues}
+
+## Current File
+\`\`\`tsx
+${currentFile}
+\`\`\`
+
+${closingInstruction}`;
+    }
+  }
+  const forceEscape = ctx.dupeBreak?.forceEscapeNextTurn === true;
+  if (ctx.dupeBreak && forceEscape) ctx.dupeBreak.forceEscapeNextTurn = false;
+  if (ctx.dupeBreak && ctx.dupeBreak.cooldown > 0) ctx.dupeBreak.cooldown--;
+  const consecutiveBrokenApplies = ctx.dupeBreak?.consecutiveBrokenApplies ?? 0;
+  const primitiveIndexMode = ctx.contextPolicy?.primitiveIndex ?? "off";
+  const primitiveIndexForceFetch = ctx.contextPolicy?.primitiveIndexForceFetch ?? false;
+  const primitiveIndexPlanTurn = ctx.contextPolicy?.primitiveIndexPlanTurn ?? false;
+  const planFirstTurn = ctx.contextPolicy?.planFirstTurn ?? false;
+  const codeFormat = ctx.contextPolicy?.codeFormat ?? "array";
+  const tools = selectTurnTools(
+    turnsUsed,
+    forceEscape,
+    consecutiveBrokenApplies,
+    hashlineMode,
+    primitiveIndexMode,
+    primitiveIndexForceFetch,
+    primitiveIndexPlanTurn,
+    planFirstTurn,
+    codeFormat
+  );
+  ctx.onPrompt?.({ turn: turnsUsed, systemPrompt, userPrompt });
+  const llmStart = Date.now();
+  const response = await codingAgent.callTools(
+    codingModel,
+    systemPrompt,
+    userPrompt,
+    tools,
+    "required",
+    [APPLY_CHANGES_TOOL_SCOPED]
+  );
+  const llmMs = Date.now() - llmStart;
+  if (costTracker) {
+    costTracker.record(codingModel, response.inputTokens, response.outputTokens, {
+      ...response.cacheReadTokens !== void 0 ? { read: response.cacheReadTokens } : {},
+      ...response.cacheCreationTokens !== void 0 ? { write: response.cacheCreationTokens } : {}
+    });
+  }
+  const tokens = { input: response.inputTokens, output: response.outputTokens };
+  const cacheTokens = {
+    ...response.cacheReadTokens !== void 0 ? { cacheReadTokens: response.cacheReadTokens } : {},
+    ...response.cacheCreationTokens !== void 0 ? { cacheCreationTokens: response.cacheCreationTokens } : {}
+  };
+  const call = response.toolCalls[0];
+  if (!call) {
+    if (ctx.dupeBreak) {
+      ctx.dupeBreak.consecutiveNoToolCalls += 1;
+    }
+    const noToolStreak = ctx.dupeBreak?.consecutiveNoToolCalls ?? 1;
+    const shouldBreak = noToolStreak >= 2;
+    console.warn(
+      `[simple] turn ${turnsUsed}: no tool call` + (shouldBreak ? ` \u2014 breaking (streak=${noToolStreak})` : ` \u2014 retrying (streak=${noToolStreak})`)
+    );
+    const retryDirective = shouldBreak ? lastResultText : `${lastResultText ?? ""}
+
+[harness] Your previous turn returned no tool call. You MUST issue an apply_changes (or scoped) tool call. Re-read the current file state and emit a corrected patch.`.trim();
+    return {
+      control: shouldBreak ? "break" : "continue",
+      compiledCode: "",
+      selfCheckPassed: false,
+      outcome: void 0,
+      phase: void 0,
+      tokens,
+      ...cacheTokens,
+      llmMs,
+      toolMs: 0,
+      lastResultText: retryDirective,
+      lastDiffFailed,
+      isEvalFeedback,
+      iconNamesCache,
+      preWarmedContext
+    };
+  }
+  if (ctx.dupeBreak) {
+    ctx.dupeBreak.consecutiveNoToolCalls = 0;
+  }
+  if (call.name === "get_available_icons") {
+    if (!iconNamesCache) {
+      iconNamesCache = LUCIDE_ICON_NAMES.join(", ");
+    }
+    console.log(`[simple] turn ${turnsUsed}: get_available_icons`);
+    let iconResult = `Available Lucide icon names (use with <Icon name="...">):
+${iconNamesCache}
+
+${ICON_LIST_NO_MATCH_GUIDANCE}`;
+    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,
+        sameExchangeBreak: { tool: call.name, repeats: iconRepeats }
+      };
+    }
+    return {
+      control: "continue",
+      compiledCode: "",
+      selfCheckPassed: false,
+      outcome: void 0,
+      phase: void 0,
+      tokens,
+      ...cacheTokens,
+      llmMs,
+      toolMs: 0,
+      lastResultText: iconResult,
+      lastDiffFailed: false,
+      isEvalFeedback: false,
+      iconNamesCache,
+      preWarmedContext
+    };
+  }
+  const toolStart = Date.now();
+  const result = await executeTool(
+    workspace,
+    call.name,
+    call.input,
+    commitMeta,
+    contract,
+    harness.what.applyPatch,
+    // Prefer the caller-threaded runtime-resolved policy
+    // (session.resolvedPolicy.context) so experimental profiles take
+    // effect. Falls back to the harness's static policy.
+    ctx.contextPolicy ?? harness.policy.context,
+    // Forward the third-party wrapper `.d.ts` map so autoCommit's
+    // typecheck overlays the real wrapper declarations and a generated
+    // direct gadget import gets strict option/return narrowing.
+    harness.what.gadgetTypes,
+    // Which tier-0 legs fire — the design-vocabulary legs stand down in
+    // `free` mode; every contract leg runs in both.
+    harness.designMode,
+    // ggui#1122: the harness's pre-filtered axis checks run at auto-commit — the serve path.
+    {
+      checks: harness.check.axisChecks,
+      classification: harness.classification,
+      originalPrompt: ctx.originalPrompt,
+      ...harness.canvas !== void 0 ? { canvas: harness.canvas } : {},
+      ...ctx.fixtureProps !== void 0 ? { fixtureProps: ctx.fixtureProps } : {}
+    }
+  );
+  const toolMs = Date.now() - toolStart;
+  if (forceEscape && ctx.dupeBreak && call.name === "apply_changes") {
+    const changes = call.input?.changes ?? [];
+    const scopedShape = changes.length === 1 && changes[0] !== void 0 && changes[0].endLine - changes[0].startLine <= 20;
+    if (scopedShape) {
+      ctx.dupeBreak.scopedEscapeUsedCount++;
+      console.log(
+        `[coding-agent] SCOPED_ESCAPE_USED | range=${changes[0]?.startLine}-${changes[0]?.endLine} | count=${ctx.dupeBreak.scopedEscapeUsedCount}`
+      );
+    }
+  }
+  const effectivePolicy = ctx.contextPolicy ?? harness.policy.context;
+  const isPatchInvalid = !!result.error && result.result.startsWith("PATCH_INVALID");
+  const isApplyChanges = call.name === "apply_changes";
+  const isFailedPatch = !result.done && isApplyChanges;
+  if (ctx.dupeBreak?.awaitingDiagnosticOutcome) {
+    ctx.dupeBreak.awaitingDiagnosticOutcome = false;
+    const commitMsg = typeof call.input?.commit_message === "string" ? call.input.commit_message : "";
+    const returnedDiag = /^\s*DIAG\s*:/i.test(commitMsg);
+    if (returnedDiag) {
+      ctx.dupeBreak.diagnosticReturnedCount++;
+      console.log(
+        `[coding-agent] DUPE_DIAGNOSTIC_RETURNED | msg=${JSON.stringify(commitMsg.slice(0, 120))}`
+      );
+    } else {
+      console.log(
+        `[coding-agent] DUPE_DIAGNOSTIC_RETURNED=false | msg=${JSON.stringify(commitMsg.slice(0, 120))}`
+      );
+    }
+    const dupeFp = ctx.dupeBreak.lastFailedPatchFingerprint;
+    let brokeLoop = false;
+    if (result.done) {
+      brokeLoop = true;
+    } else if (isApplyChanges && dupeFp) {
+      const { computePatchFingerprint } = await import('./dupe-break-X6K7QFIS.js');
+      const changes2 = call.input?.changes ?? [];
+      const errText2 = extractFailSignature(result.result);
+      const currentFp = computePatchFingerprint(changes2, errText2);
+      brokeLoop = currentFp !== dupeFp;
+    } else {
+      brokeLoop = true;
+    }
+    if (brokeLoop) {
+      ctx.dupeBreak.diagnosticBrokeLoopCount++;
+      console.log(`[coding-agent] DUPE_DIAGNOSTIC_BROKE_LOOP=true`);
+    } else {
+      console.log(`[coding-agent] DUPE_DIAGNOSTIC_BROKE_LOOP=false`);
+    }
+  }
+  let augmentedResultText = result.result;
+  if (isFailedPatch && effectivePolicy?.breakDuplicatePatch && ctx.dupeBreak) {
+    const { computePatchFingerprint } = await import('./dupe-break-X6K7QFIS.js');
+    const changes = call.input?.changes ?? [];
+    const errText = extractFailSignature(result.result);
+    const fingerprint = computePatchFingerprint(changes, errText);
+    const priorPrint = ctx.dupeBreak.lastFailedPatchFingerprint;
+    const inCooldown = ctx.dupeBreak.cooldown > 0;
+    if (priorPrint && priorPrint === fingerprint && !inCooldown) {
+      ctx.dupeBreak.cooldown = 3;
+      ctx.dupeBreak.firedCount++;
+      const action = effectivePolicy.dupeBreakAction ?? "escape";
+      console.log(
+        `[coding-agent] DUPLICATE_PATCH_BREAK fired | action=${action} | fingerprint=${fingerprint.slice(0, 12)} error=${JSON.stringify(errText.slice(0, 48))}`
+      );
+      const codeHead = (() => {
+        const sorted = [...changes].sort(
+          (a, b) => a.startLine - b.startLine || a.endLine - b.endLine
+        );
+        const flat = sorted.map((c) => Array.isArray(c.code) ? c.code.join("\n") : String(c.code ?? "")).join("\n");
+        return flat.slice(0, 200);
+      })();
+      const rangesShort = [...changes].sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine).map((c) => `${c.startLine}-${c.endLine}`).join(", ");
+      const errClass = (errText || "unknown").toLowerCase().slice(0, 60);
+      const summary = { rangesShort, codeHead, errClass, fingerprint };
+      ctx.dupeBreak.recentFailedPatches = [
+        summary,
+        ...ctx.dupeBreak.recentFailedPatches
+      ].slice(0, 2);
+      if (action === "diagnostic" || action === "diagnostic-noforce") {
+        ctx.dupeBreak.pendingDiagnosticTurn = true;
+        ctx.dupeBreak.diagnosticFiredCount++;
+        augmentedResultText = `[DUPLICATE_PATCH] Identical failed patch detected.
+Your previous patch was byte-identical to one you tried before and failed for the same reason. The next prompt will give you a focused excerpt of the failing region with line numbers and require a one-line structured diagnosis (in commit_message) before your next patch. Your next apply_changes MUST differ materially from the prior failed patch \u2014 different ranges OR meaningfully different code.
+
+Repeated error: ${errText}
+
+---
+
+` + result.result;
+      } else {
+        ctx.dupeBreak.forceEscapeNextTurn = true;
+        augmentedResultText = `[DUPLICATE_PATCH] Identical failed patch detected.
+Your previous patch failed with the same error, and this retry is byte-identical.
+The next turn is FORCED to a scoped single-change apply_changes (one change, \u226420 lines). Target the minimal failing region \u2014 do not retry the full patch. The rest of the file is correct.
+
+Repeated error: ${errText}
+
+---
+
+` + result.result;
+      }
+    }
+    ctx.dupeBreak.lastFailedPatchFingerprint = fingerprint;
+  }
+  if (result.done && ctx.dupeBreak?.lastFailedPatchFingerprint) {
+    ctx.dupeBreak.lastFailedPatchFingerprint = null;
+  }
+  if (ctx.dupeBreak && call.name === "apply_changes") {
+    const wasBrokenApply = result.result.startsWith("PATCH_APPLIED_BROKEN");
+    if (wasBrokenApply) {
+      ctx.dupeBreak.consecutiveBrokenApplies++;
+    } else if (!result.error) {
+      ctx.dupeBreak.consecutiveBrokenApplies = 0;
+    }
+  } 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;
+    }
+  }
+  const isWrite = call.name === "apply_changes" || call.name === "rewrite";
+  let repeatedFailure;
+  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;
+      }
+    }
+  }
+  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,
+      sameExchangeBreak: { tool: call.name, repeats: sameExchangeRepeats }
+    };
+  }
+  if (repeatedFailure !== void 0 && 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))} \u2014 terminating run (ggui#1791)`
+    );
+    return {
+      control: "break",
+      compiledCode: "",
+      selfCheckPassed: false,
+      outcome: void 0,
+      phase: void 0,
+      tokens,
+      ...cacheTokens,
+      llmMs,
+      toolMs,
+      lastResultText: augmentedResultText,
+      lastDiffFailed: false,
+      isEvalFeedback: false,
+      iconNamesCache,
+      preWarmedContext,
+      sameFailureBreak: { signature, repeats: repeatedFailure.repeats }
+    };
+  }
+  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";
+  const phase = a1Phase === "scaffold" ? "scaffold" : a1Phase === "fill" ? "fill" : turnsUsed === 1 ? "impl" : isEvalFeedback ? "eval-fix" : "patch";
+  console.log(
+    `[simple] turn ${turnsUsed} (${phase}): ${outcome} | llm=${llmMs}ms tool=${toolMs}ms | in=${response.inputTokens} out=${response.outputTokens}`
+  );
+  if (!result.done) {
+    const preview = JSON.stringify(call.input).slice(0, 150);
+    console.log(`[simple] turn ${turnsUsed} preview: ${preview}...`);
+  }
+  if (!result.done) {
+    return {
+      control: "continue",
+      compiledCode: "",
+      selfCheckPassed: false,
+      outcome,
+      phase,
+      tokens,
+      ...cacheTokens,
+      llmMs,
+      toolMs,
+      // Use the augmented text so the next turn's prompt gets the
+      // [DUPLICATE_PATCH] preface when dupe-break fired (noop otherwise).
+      lastResultText: augmentedResultText,
+      lastDiffFailed: turnDiffFailed,
+      isEvalFeedback: false,
+      iconNamesCache,
+      preWarmedContext
+    };
+  }
+  let compiledCode = "";
+  let selfCheckPassed = false;
+  for (const [, meta] of commitMeta) {
+    if (meta.build.success && meta.selfCheck.passed && meta.build.compiledCode) {
+      compiledCode = meta.build.compiledCode;
+      selfCheckPassed = true;
+    }
+  }
+  if (!compiledCode) {
+    for (const [, meta] of commitMeta) {
+      if (meta.build.success && meta.build.compiledCode) {
+        compiledCode = meta.build.compiledCode;
+      }
+    }
+  }
+  return {
+    control: "proceed",
+    compiledCode,
+    selfCheckPassed,
+    outcome,
+    phase,
+    tokens,
+    ...cacheTokens,
+    llmMs,
+    toolMs,
+    lastResultText,
+    lastDiffFailed: turnDiffFailed,
+    isEvalFeedback,
+    iconNamesCache,
+    preWarmedContext
+  };
+}
+
+// src/harness/enforced-coding.ts
+function mapProviderForEvaluator(provider) {
+  return provider === "anthropic" ? "claude" : provider;
+}
+function visionJudgeProvider(provider) {
+  switch (provider) {
+    case "anthropic":
+      return "claude";
+    case "google":
+      return "google";
+    case "openai":
+    case "openrouter":
+      return void 0;
+  }
+}
+
+// src/harness/coding/run-eval-round.ts
+var MAX_FEEDBACK_ISSUES = 3;
+function isFitFail(issue) {
+  return issue.result === "fail" && issue.category === "visual" && issue.subcategory === "canvas-overflow";
+}
+var FIT_FINGERPRINT_PREFIX = "visual|canvas-overflow|";
+function formatFitFeedback(issue) {
+  return `[fit] ${issue.category}/${issue.subcategory ?? ""}: ${issue.description}
+  Fix: ${issue.fix ?? ""}`;
+}
+var EVAL_ROUND_THREW_REASON = "eval round threw";
+var PROBE_ONLY_CRITERIA_REASON = "probe-only round: no evaluator configured";
+var PROBE_ONLY_VISUAL_REASON = "probe-only round: no visual evaluator configured";
+var PROBE_ONLY_PASS = "probe-only";
+var COST_TRACKER_ABSENT_REASON = "cost tracker absent on an evaluation round";
+function requireCostTracker(costTracker) {
+  if (costTracker === null) throw new Error(COST_TRACKER_ABSENT_REASON);
+  return costTracker;
+}
+function runVisualLeg(visualEvalAgent, run, measureFit) {
+  const provider = visionJudgeProvider(visualEvalAgent.provider);
+  if (provider === void 0) {
+    const noJudge = `no vision judge for provider '${visualEvalAgent.provider}' (model ${visualEvalAgent.model}) \u2014 the in-loop visual judge runs on a vision provider (anthropic, google)`;
+    if (measureFit === void 0) {
+      return Promise.resolve({ issues: [], coverage: { status: "skipped", reason: noJudge } });
+    }
+    const notMeasured = (why) => ({
+      issues: [],
+      coverage: { status: "skipped", reason: `${noJudge}; fit not measured: ${why}` }
+    });
+    return measureFit().then(
+      (fit) => fit.status === "measured" ? {
+        issues: fit.issues,
+        coverage: { status: "skipped", reason: `${noJudge}; fit measured without the judge: ${describeFitReadings(fit.readings)}` }
+      } : notMeasured(fit.reason),
+      (e) => notMeasured(e instanceof Error ? e.message : String(e))
+    );
+  }
+  return run(provider).catch((e) => ({
+    issues: [],
+    coverage: { status: "skipped", reason: `visual leg failed: ${e instanceof Error ? e.message : String(e)}` }
+  }));
+}
+function describeFitReadings(readings) {
+  return readings.map((r) => `${r.canvas} ${r.viewport.width}\xD7${r.viewport.height} content ${r.contentHeight ?? "?"}px${r.overflow ? " (overflow)" : ""}`).join(", ");
+}
+var LOW_RISK_BYPASS_REASON = "same-image low-risk bypass: axis checks clean, tier-1/2 evaluation not invoked";
+function selectActionableFeedback(issues) {
+  const pool = issues.filter((i) => i.result === "fail" || i.result === "warn");
+  const reserved = pool.find((i) => i.tier === 0 && i.result === "fail");
+  return [
+    ...reserved ? [reserved] : [],
+    ...pool.filter((i) => i !== reserved).sort((a, b) => (a.result === "fail" ? 0 : 1) - (b.result === "fail" ? 0 : 1))
+  ].slice(0, MAX_FEEDBACK_ISSUES);
+}
+function fingerprintFail(issue) {
+  const cat = issue.category ?? "";
+  const sub = issue.subcategory ?? "";
+  const desc = (issue.description ?? "").toLowerCase().replace(/line\s+\d+/g, "line N").replace(/\s+/g, " ").trim().slice(0, 40);
+  return `${cat}|${sub}|${desc}`;
+}
+function failedCheckKinds(probeIssues) {
+  const failed = /* @__PURE__ */ new Set();
+  for (const issue of probeIssues) {
+    if (issue.result !== "fail" || issue.subcategory === void 0) continue;
+    const kind = parseRuntimeSubcategory(issue.subcategory);
+    if (kind !== void 0) failed.add(kind);
+  }
+  return RENDER_CHECK_KINDS.filter((kind) => failed.has(kind));
+}
+function probeMetaOf(outcome, probeIssues) {
+  const detail = {
+    ...outcome.reason !== void 0 ? { reason: outcome.reason } : {},
+    ...outcome.renderMs !== void 0 ? { renderMs: outcome.renderMs } : {},
+    ...outcome.hostLoad !== void 0 ? { hostLoad: outcome.hostLoad } : {},
+    ...outcome.queuedMs !== void 0 ? { queuedMs: outcome.queuedMs } : {},
+    ...outcome.pendingAffordance !== void 0 ? { pendingAffordance: outcome.pendingAffordance } : {}
+  };
+  const elapsed = outcome.elapsedMs !== void 0 ? { elapsedMs: outcome.elapsedMs } : {};
+  if (outcome.status !== "ran") {
+    return { status: outcome.status, ...elapsed, ...detail };
+  }
+  const [first, ...rest] = failedCheckKinds(probeIssues);
+  if (first === void 0) {
+    return { status: "ran", verdict: "pass", ...elapsed, ...detail };
+  }
+  return { status: "ran", verdict: "fail", failChecks: [first, ...rest], ...elapsed, ...detail };
+}
+function describeProbeMeta(meta) {
+  if (meta.verdict === void 0) return meta.status;
+  return meta.verdict === "pass" ? "ran, verdict pass" : `ran, verdict fail (${meta.failChecks.join(", ")})`;
+}
+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: [],
+      meta: {
+        status: "not-applicable",
+        reason: probe ? "no compiled code" : "no runtimeRender check configured"
+      }
+    };
+  }
+  let outcome;
+  try {
+    outcome = await probe.run({
+      sourceCode,
+      compiledCode,
+      contract,
+      fixtureProps
+    });
+  } catch (e) {
+    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 = probeMetaOf(outcome, outcome.issues);
+  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, meta };
+}
+function formatRuntimeProbeFeedback(issue) {
+  const subcat = issue.subcategory ? `/${issue.subcategory}` : "";
+  return `[runtime] ${issue.category}${subcat}: ${issue.description}
+  Fix: ${issue.fix ?? ""}`;
+}
+var FEEDBACK_PROBE_CHECKS = ["prop-sensitivity"];
+var CONTRACT_FEEDBACK_BONUS = 1;
+function isFeedbackProbeFail(issue) {
+  const sub = issue.subcategory;
+  if (issue.result !== "fail" || typeof sub !== "string") return false;
+  return FEEDBACK_PROBE_CHECKS.some((check) => sub === `runtime:${check}` || sub.startsWith(`runtime:${check}:`));
+}
+function contractFeedbackRecord(fails, sourceBefore) {
+  return { firedOn: fails.flatMap((i) => i.subcategory !== void 0 ? [i.subcategory] : []), sourceBefore };
+}
+function contractFeedbackFails(exitProbe, alreadyFedBack) {
+  if (!exitProbe.fired) return [];
+  return exitProbe.probeIssues.filter((i) => isFeedbackProbeFail(i) && !alreadyFedBack.has(fingerprintFail(i)));
+}
+async function runEvalRound(ctx, input) {
+  const {
+    workspace,
+    harness,
+    contract,
+    userPrompt,
+    fixtureProps,
+    classification,
+    evaluationAgent,
+    visualEvalAgent,
+    visualEvaluation,
+    visualThreshold,
+    qualityMode,
+    maxEvalRounds,
+    llmEvalMod,
+    visualMod,
+    preWarmPromise,
+    onProgress,
+    probeOnly,
+    probeRepairUsed,
+    probeRepairTrigger
+  } = ctx;
+  const { compiledCode, prevModeSubcats, prevFailFingerprints } = input;
+  let { evalRoundsUsed, preWarmedContext } = input;
+  evalRoundsUsed++;
+  onProgress?.({ type: "generating", phase: "evaluating" });
+  const currentSource = workspace.read() ?? "";
+  let evalResult;
+  let evalTokens = { input: 0, output: 0 };
+  let inLoopVisualTokens = void 0;
+  let evalLlmMs = 0;
+  try {
+    if (probeOnly) {
+      const exitProbe = await runProbeAtExit({
+        harness,
+        sourceCode: currentSource,
+        compiledCode,
+        contract,
+        fixtureProps
+      });
+      const probeOnlyResult = {
+        issues: [...exitProbe.probeIssues],
+        pass: [PROBE_ONLY_PASS],
+        runtimeProbe: exitProbe.meta,
+        criteriaCoverage: notApplicableCoverage(PROBE_ONLY_CRITERIA_REASON),
+        visualCoverage: { status: "not-applicable", reason: PROBE_ONLY_VISUAL_REASON }
+      };
+      const recoverableFail = exitProbe.fired && exitProbe.recoverableFail;
+      if (probeRepairUsed) {
+        if (probeRepairTrigger === void 0) {
+          throw new Error("harness defect: a probe-only re-probe round without the probe that bought the repair turn");
+        }
+        const repair = { attempted: true, compiled: true, trigger: probeRepairTrigger };
+        evalResult = { ...probeOnlyResult, runtimeProbeRepair: repair };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: probe-only re-probe after the repair turn \u2014 ${describeProbeMeta(exitProbe.meta)}${recoverableFail ? ", recoverable crash still present" : ""} \u2014 serving`
+        );
+        return {
+          control: "break",
+          evalDone: true,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats,
+          prevFailFingerprints,
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: "",
+          isEvalFeedback: false,
+          lastDiffFailed: false
+        };
+      }
+      evalResult = probeOnlyResult;
+      if (recoverableFail) {
+        const runtimeFails = exitProbe.probeIssues.filter(
+          (i) => i.result === "fail" && i.subcategory?.startsWith("runtime:")
+        );
+        const lines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: probe-only round \u2014 runtime probe fail (recoverable) \u2014 granting the one repair turn`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats,
+          prevFailFingerprints,
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false
+        };
+      }
+      console.log(
+        `[simple] eval round ${evalRoundsUsed}: probe-only round \u2014 probe ${describeProbeMeta(exitProbe.meta)} \u2014 serving`
+      );
+      return {
+        control: "break",
+        evalDone: true,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats,
+        prevFailFingerprints,
+        preWarmedContext,
+        evalTokens,
+        ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+        evalLlmMs,
+        lastResultText: "",
+        isEvalFeedback: false,
+        lastDiffFailed: false
+      };
+    }
+    const checkResult = await runCheck({
+      harness,
+      sourceCode: currentSource,
+      compiledCode,
+      contract,
+      prompt: userPrompt,
+      fixtureProps,
+      skipRuntimeRender: true
+    });
+    const modeIssues = [...checkResult.issues];
+    const modeHasBlocking = modeIssues.some((i) => i.result === "fail");
+    const contractDeclaresGadgets = contract !== void 0 && listContractGadgets(contract).length > 0;
+    if (classification.riskTier === "low" && !modeHasBlocking && !contractDeclaresGadgets) {
+      const exitProbe = await runProbeAtExit({
+        harness,
+        sourceCode: currentSource,
+        compiledCode,
+        contract,
+        fixtureProps
+      });
+      if (exitProbe.fired && exitProbe.recoverableFail) {
+        const runtimeFails = exitProbe.probeIssues.filter(
+          (i) => i.result === "fail" && i.subcategory?.startsWith("runtime:")
+        );
+        const lines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        const allIssues2 = [...modeIssues, ...exitProbe.probeIssues];
+        evalResult = {
+          issues: allIssues2,
+          pass: ["axis.low-risk"],
+          criteriaCoverage: notApplicableCoverage(LOW_RISK_BYPASS_REASON),
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: low-risk bypass clean BUT runtime probe fail (recoverable) \u2014 granting +1 turn`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats,
+          prevFailFingerprints,
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false
+        };
+      }
+      evalResult = {
+        issues: [...modeIssues, ...exitProbe.probeIssues],
+        pass: ["axis.low-risk"],
+        criteriaCoverage: notApplicableCoverage(LOW_RISK_BYPASS_REASON),
+        runtimeProbe: exitProbe.meta
+      };
+      console.log(
+        `[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",
+        evalDone: true,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats,
+        prevFailFingerprints,
+        preWarmedContext,
+        evalTokens,
+        ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+        evalLlmMs,
+        lastResultText: "",
+        isEvalFeedback: false,
+        lastDiffFailed: false
+      };
+    }
+    const costTracker = requireCostTracker(ctx.costTracker);
+    if (evalRoundsUsed === 1 && !preWarmedContext && preWarmPromise) {
+      preWarmedContext = await preWarmPromise;
+    }
+    let llmResult = null;
+    let visualIssues = null;
+    const visualContext = {
+      compiledCode,
+      originalPrompt: userPrompt,
+      profile: harness.profile,
+      // The caller's theme, when named — the round paints what the app paints.
+      ...visualEvaluation?.cssTokens !== void 0 ? { cssTokens: visualEvaluation.cssTokens } : {},
+      // ggui#1436 — the criteria bank and the card's context; the judge selects per canvas, report-only.
+      ...visualEvaluation?.criteriaBank !== void 0 ? {
+        criteria: {
+          bank: visualEvaluation.criteriaBank,
+          context: criteriaContextFor({
+            classification,
+            contract,
+            cssTokens: visualEvaluation.cssTokens,
+            profile: harness.profile,
+            shell: ctx.shellType ?? "unknown",
+            ...visualEvaluation.criteriaKind !== void 0 ? { kind: visualEvaluation.criteriaKind } : {}
+          })
+        }
+      } : {}
+    };
+    const visualFrame = {
+      // The in-loop visual round renders the same sample the runtime probe
+      // does (the caller's fixture) unless the config names its own.
+      sampleProps: visualEvaluation?.sampleProps ?? fixtureProps,
+      // Per-canvas judging (arm-neutral) — absent = single shot.
+      ...visualEvaluation?.canvases !== void 0 ? { canvases: visualEvaluation.canvases } : {},
+      // ggui#1195 — the declared box per canvas (same-target with the composer).
+      ...visualEvaluation?.canvasViewports !== void 0 ? { canvasViewports: visualEvaluation.canvasViewports } : {}
+    };
+    const measureFit = visualMod && visualFrame.canvases !== void 0 && visualFrame.canvases.length > 0 ? () => visualMod.runVisualFit(visualContext, visualFrame) : void 0;
+    const evalLlmStart = Date.now();
+    const [llm, visual] = await Promise.all([
+      llmEvalMod ? llmEvalMod.runLLMEvaluation(
+        {
+          sourceCode: currentSource,
+          originalPrompt: userPrompt,
+          contract,
+          // Criteria + mother prompt follow the triad that produced
+          // the source (free mode: color-only tokens, arm-neutral
+          // visual judging).
+          designMode: harness.designMode,
+          profile: harness.profile
+        },
+        {
+          provider: mapProviderForEvaluator(evaluationAgent.provider),
+          model: evaluationAgent.model,
+          // #484 — thread the coding-agent's routing override
+          // through to the evaluator so its LLM call never falls
+          // back to `process.env` either (the eval calls run
+          // inside the same concurrent generation, so the race is
+          // real here too, not just on the coding turn).
+          routeOverride: evaluationAgent.routeOverride,
+          // #489 — thread the same provider-429-retry observer.
+          // Without this, a rate-limited retry inside the
+          // evaluation agent's apiCall() happens (the base-class
+          // retry loop is unconditional) but never reaches the
+          // caller, silently missing the host application's
+          // structured log.
+          onRetry: evaluationAgent.onRetry
+        },
+        preWarmedContext
+      ) : null,
+      visualMod ? runVisualLeg(
+        visualEvalAgent,
+        (provider) => visualMod.runVisualEval(visualContext, {
+          provider,
+          model: visualEvalAgent.model,
+          passThreshold: visualThreshold,
+          viewport: visualEvaluation?.viewport,
+          ...visualFrame,
+          // #484/#489 — same threading as the LLM-eval leg above:
+          // the visual eval's multimodal call runs inside the same
+          // concurrent generation, so it needs the same routing
+          // override (never fall back to `process.env`) and the
+          // same provider-429-retry observer (retries reach the
+          // host application's structured log).
+          routeOverride: visualEvalAgent.routeOverride,
+          onRetry: visualEvalAgent.onRetry
+        }),
+        measureFit
+      ) : null
+    ]);
+    evalLlmMs = Date.now() - evalLlmStart;
+    llmResult = llm;
+    visualIssues = visual?.issues ?? null;
+    inLoopVisualTokens = visual?.tokens;
+    if (inLoopVisualTokens !== void 0) {
+      costTracker.record(visualEvalAgent.model, inLoopVisualTokens.inputTokens, inLoopVisualTokens.outputTokens);
+      const criteriaSpend = inLoopVisualTokens.criteria;
+      if (criteriaSpend !== void 0) costTracker.record(visualEvalAgent.model, criteriaSpend.inputTokens, criteriaSpend.outputTokens);
+    }
+    const visualSummary = visual?.summary;
+    const visualCoverage = visual?.coverage ?? { status: "not-applicable", reason: "visual leg not configured" };
+    if (visualCoverage.status === "skipped") {
+      console.log(`[eval] visual-judge: SKIPPED (${visualCoverage.reason ?? "no reason recorded"})`);
+    }
+    if (llmResult) {
+      costTracker.record(evaluationAgent.model, llmResult.inputTokens, llmResult.outputTokens, {
+        ...llmResult.cacheReadTokens !== void 0 ? { read: llmResult.cacheReadTokens } : {},
+        ...llmResult.cacheCreationTokens !== void 0 ? { write: llmResult.cacheCreationTokens } : {}
+      });
+      evalTokens = {
+        input: llmResult.inputTokens,
+        output: llmResult.outputTokens,
+        ...llmResult.cacheReadTokens !== void 0 ? { cacheRead: llmResult.cacheReadTokens } : {},
+        ...llmResult.cacheCreationTokens !== void 0 ? { cacheCreation: llmResult.cacheCreationTokens } : {}
+      };
+    }
+    const allIssues = [
+      ...llmResult?.issues ?? [],
+      ...visualIssues ?? [],
+      ...modeIssues
+    ];
+    const allPass = [...llmResult?.pass ?? []];
+    evalResult = {
+      issues: allIssues,
+      pass: allPass,
+      ...llmResult?.criteriaCoverage !== void 0 ? { criteriaCoverage: llmResult.criteriaCoverage } : {},
+      // Per-canvas visual summary — present only when canvases were
+      // requested and the leg ran; every later re-stamp spreads this
+      // base so it survives to the assembled result.
+      ...visualSummary !== void 0 ? { visual: visualSummary } : {},
+      visualCoverage
+    };
+    const fails = allIssues.filter((i) => i.result === "fail");
+    const warns = allIssues.filter((i) => i.result === "warn");
+    const modeFails = modeIssues.filter((i) => i.result === "fail").length;
+    const modeWarns = modeIssues.filter((i) => i.result === "warn").length;
+    const modeSubcatCounts = modeIssues.reduce((acc, i) => {
+      const key = i.subcategory ?? "mode";
+      acc[key] = (acc[key] ?? 0) + 1;
+      return acc;
+    }, {});
+    const modeBreakdown = Object.entries(modeSubcatCounts).map(([k, v]) => `${k}\xD7${v}`).join(", ");
+    const currSubcats = new Set(Object.keys(modeSubcatCounts));
+    let crossRound = "";
+    if (evalRoundsUsed > 1 && (prevModeSubcats.size > 0 || currSubcats.size > 0)) {
+      const unresolved = [...currSubcats].filter((s) => prevModeSubcats.has(s));
+      const fixed = [...prevModeSubcats].filter((s) => !currSubcats.has(s));
+      const fresh = [...currSubcats].filter((s) => !prevModeSubcats.has(s));
+      const parts = [];
+      if (unresolved.length) parts.push(`unresolved=[${unresolved.join(",")}]`);
+      if (fixed.length) parts.push(`fixed=[${fixed.join(",")}]`);
+      if (fresh.length) parts.push(`new=[${fresh.join(",")}]`);
+      if (parts.length) crossRound = ` | ${parts.join(" ")}`;
+    }
+    const updatedPrevModeSubcats = currSubcats;
+    console.log(
+      `[simple] eval round ${evalRoundsUsed}: ${fails.length} fails, ${warns.length} warns | cost=$${costTracker.getTotal().toFixed(4)} | tiers: t1+2=${llmResult?.issues.length ?? 0} visual=${visualIssues?.length ?? 0} axis[${classification.riskTier}]=${modeFails}F/${modeWarns}W${modeBreakdown ? ` (${modeBreakdown})` : ""}${crossRound}`
+    );
+    const blocking = evalResult.issues.filter((i) => i.result === "fail");
+    const visualMajorsActed = visualEvaluation?.actOn === "major" ? (visualIssues ?? []).filter((i) => i.origin === "judge" && i.result === "warn" && i.severity === "major") : [];
+    const shouldContinue = qualityMode === "fast" ? blocking.length > 0 || visualMajorsActed.length > 0 : blocking.length > 0 || warns.length > 0;
+    const currFailFingerprints = new Set(blocking.map(fingerprintFail));
+    if (!shouldContinue) {
+      const exitProbe = await runProbeAtExit({
+        harness,
+        sourceCode: currentSource,
+        compiledCode,
+        contract,
+        fixtureProps
+      });
+      if (exitProbe.fired && exitProbe.recoverableFail) {
+        const runtimeFails = exitProbe.probeIssues.filter(
+          (i) => i.result === "fail" && i.subcategory?.startsWith("runtime:")
+        );
+        const lines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        const enrichedIssues = [...allIssues, ...exitProbe.probeIssues];
+        evalResult = { ...evalResult, issues: enrichedIssues, pass: allPass, runtimeProbe: exitProbe.meta };
+        const enrichedFingerprints = /* @__PURE__ */ new Set([
+          ...currFailFingerprints,
+          ...runtimeFails.map(fingerprintFail)
+        ]);
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: tier-1/2 clean BUT runtime probe fail (recoverable) \u2014 granting +1 turn`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: enrichedFingerprints,
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false
+        };
+      }
+      const contractFails = contractFeedbackFails(exitProbe, prevFailFingerprints);
+      if (contractFails.length > 0 && evalRoundsUsed < maxEvalRounds + CONTRACT_FEEDBACK_BONUS) {
+        const lines = contractFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        evalResult = {
+          ...evalResult,
+          issues: [...allIssues, ...exitProbe.probeIssues],
+          pass: allPass,
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: tier-1/2 clean BUT contract probe fail \u2014 granting +1 turn (ggui#1261; ${contractFails.map((i) => i.subcategory).join(", ")})`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...contractFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+          contractFeedback: contractFeedbackRecord(contractFails, currentSource)
+        };
+      }
+      evalResult = {
+        ...evalResult,
+        issues: [...allIssues, ...exitProbe.probeIssues],
+        pass: allPass,
+        runtimeProbe: exitProbe.meta
+      };
+      console.log(`[simple] eval round ${evalRoundsUsed}: no blocking issues \u2014 PASS`);
+      return {
+        control: "break",
+        evalDone: true,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats: updatedPrevModeSubcats,
+        prevFailFingerprints: currFailFingerprints,
+        preWarmedContext,
+        evalTokens,
+        ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+        evalLlmMs,
+        lastResultText: "",
+        isEvalFeedback: false,
+        lastDiffFailed: false
+      };
+    }
+    const onlyExtensionExemptFails = currFailFingerprints.size > 0 && [...currFailFingerprints].every((fp) => fp.includes("|runtime:") || fp.startsWith(FIT_FINGERPRINT_PREFIX));
+    if (evalRoundsUsed > 1 && currFailFingerprints.size > 0 && !onlyExtensionExemptFails && [...currFailFingerprints].every((fp) => prevFailFingerprints.has(fp))) {
+      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 = {
+        ...evalResult,
+        issues: [...evalResult.issues, ...stuckExitProbe.probeIssues],
+        runtimeProbe: stuckExitProbe.meta
+      };
+      const stuckContractFails = contractFeedbackFails(stuckExitProbe, prevFailFingerprints);
+      if (stuckContractFails.length > 0 && evalRoundsUsed < maxEvalRounds + CONTRACT_FEEDBACK_BONUS) {
+        const lines = stuckContractFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: stuck BUT contract probe fail never delivered \u2014 granting +1 turn (ggui#1261; ${stuckContractFails.map((i) => i.subcategory).join(", ")})`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...stuckContractFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: lines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+          contractFeedback: contractFeedbackRecord(stuckContractFails, currentSource)
+        };
+      }
+      return {
+        control: "break",
+        evalDone: false,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats: updatedPrevModeSubcats,
+        prevFailFingerprints: currFailFingerprints,
+        preWarmedContext,
+        evalTokens,
+        ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+        evalLlmMs,
+        lastResultText: "",
+        isEvalFeedback: false,
+        lastDiffFailed: false
+      };
+    }
+    const RUNTIME_EXTENSION_BONUS = 2;
+    const FIT_EXTENSION_BONUS = 1;
+    if (evalRoundsUsed >= maxEvalRounds) {
+      const exitProbe = await runProbeAtExit({
+        harness,
+        sourceCode: currentSource,
+        compiledCode,
+        contract,
+        fixtureProps
+      });
+      const hasRuntimeFail = exitProbe.fired && exitProbe.recoverableFail;
+      const allowRuntimeExtension = hasRuntimeFail && evalRoundsUsed < maxEvalRounds + RUNTIME_EXTENSION_BONUS;
+      const fitFails = evalResult.issues.filter(isFitFail);
+      const allowFitExtension = !allowRuntimeExtension && fitFails.length > 0 && evalRoundsUsed < maxEvalRounds + FIT_EXTENSION_BONUS;
+      if (allowFitExtension) {
+        const fitLines = fitFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatFitFeedback);
+        evalResult = {
+          ...evalResult,
+          issues: [...evalResult.issues, ...exitProbe.probeIssues],
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: fit fail active at cap \u2014 granting +1 retry (ggui#1195; ${fitFails.length} canvas-overflow)`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...fitFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: fitLines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false
+        };
+      }
+      const capContractFails = allowRuntimeExtension ? [] : contractFeedbackFails(exitProbe, prevFailFingerprints);
+      if (capContractFails.length > 0 && evalRoundsUsed < maxEvalRounds + CONTRACT_FEEDBACK_BONUS) {
+        const contractLines = capContractFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+        evalResult = {
+          ...evalResult,
+          issues: [...evalResult.issues, ...exitProbe.probeIssues],
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(
+          `[simple] eval round ${evalRoundsUsed}: contract probe fail active at cap \u2014 granting +1 retry (ggui#1261; ${capContractFails.map((i) => i.subcategory).join(", ")})`
+        );
+        return {
+          control: "feedback",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: /* @__PURE__ */ new Set([...currFailFingerprints, ...capContractFails.map(fingerprintFail)]),
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: contractLines.join("\n\n"),
+          isEvalFeedback: true,
+          lastDiffFailed: false,
+          contractFeedback: contractFeedbackRecord(capContractFails, currentSource)
+        };
+      }
+      if (!allowRuntimeExtension) {
+        evalResult = {
+          ...evalResult,
+          issues: [...evalResult.issues, ...exitProbe.probeIssues],
+          runtimeProbe: exitProbe.meta
+        };
+        console.log(`[simple] eval round ${evalRoundsUsed}: max eval rounds reached \u2014 stopping`);
+        return {
+          control: "break",
+          evalDone: false,
+          evalResult,
+          evalRoundsUsed,
+          prevModeSubcats: updatedPrevModeSubcats,
+          prevFailFingerprints: currFailFingerprints,
+          preWarmedContext,
+          evalTokens,
+          ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+          evalLlmMs,
+          lastResultText: "",
+          isEvalFeedback: false,
+          lastDiffFailed: false
+        };
+      }
+      const runtimeFails = exitProbe.probeIssues.filter(
+        (i) => i.result === "fail" && i.subcategory?.startsWith("runtime:")
+      );
+      const probeLines = runtimeFails.slice(0, MAX_FEEDBACK_ISSUES).map(formatRuntimeProbeFeedback);
+      const enrichedIssues = [...evalResult.issues, ...exitProbe.probeIssues];
+      evalResult = { ...evalResult, issues: enrichedIssues, 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)`
+      );
+      return {
+        control: "feedback",
+        evalDone: false,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats: updatedPrevModeSubcats,
+        prevFailFingerprints: /* @__PURE__ */ new Set([
+          ...currFailFingerprints,
+          ...runtimeFails.map(fingerprintFail)
+        ]),
+        preWarmedContext,
+        evalTokens,
+        ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+        evalLlmMs,
+        lastResultText: probeLines.join("\n\n"),
+        isEvalFeedback: true,
+        lastDiffFailed: false
+      };
+    }
+    if (!costTracker.canContinue()) {
+      console.log(
+        `[simple] eval: budget exhausted (spent=$${costTracker.getTotal().toFixed(4)}) \u2014 stopping`
+      );
+      return {
+        control: "break",
+        evalDone: false,
+        evalResult,
+        evalRoundsUsed,
+        prevModeSubcats: updatedPrevModeSubcats,
+        prevFailFingerprints: currFailFingerprints,
+        preWarmedContext,
+        evalTokens,
+        ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+        evalLlmMs,
+        lastResultText: "",
+        isEvalFeedback: false,
+        lastDiffFailed: false
+      };
+    }
+    const allActionable = selectActionableFeedback(evalResult.issues);
+    const issueLines = allActionable.map((issue) => {
+      const tag = issue.result === "fail" ? "FAIL" : "WARN";
+      return `[${tag}] ${issue.category}${issue.subcategory ? "/" + issue.subcategory : ""}: ${issue.description}
+  Fix: ${issue.fix}`;
+    });
+    console.log(
+      `[simple] eval round ${evalRoundsUsed}: ${allActionable.length} issues (${blocking.length} fail, ${warns.length} warn) \u2192 feeding back to coding loop`
+    );
+    for (const issue of evalResult.issues) {
+      if (issue.tier !== 0 || issue.result !== "fail" && issue.result !== "warn") continue;
+      console.log(
+        `[simple] eval round ${evalRoundsUsed}: tier0 ${issue.result} ${issue.subcategory ?? issue.category} delivered=${allActionable.includes(issue)}`
+      );
+    }
+    if (visualEvaluation?.actOn !== void 0) {
+      console.log(
+        `[simple] eval round ${evalRoundsUsed}: continuing: fails=${blocking.length}, visual majors acted=${visualMajorsActed.length} (actOn=${visualEvaluation.actOn})`
+      );
+    }
+    return {
+      control: "feedback",
+      evalDone: false,
+      evalResult,
+      evalRoundsUsed,
+      prevModeSubcats: updatedPrevModeSubcats,
+      // DELIVERED fails only (Exp 54 P1 addendum, proposal 2): the
+      // stuck detector's premise is "the LLM saw these and did not
+      // resolve them" — recording fails that the MAX_FEEDBACK_ISSUES
+      // cap cut from the feedback turns truncation into a premature
+      // stuck-exit (the model never saw the issue it is blamed for
+      // not fixing). An undelivered fail recurring next round now
+      // reads as NEW, gets delivered, and earns its fix round.
+      prevFailFingerprints: new Set(
+        allActionable.filter((i) => i.result === "fail").map(fingerprintFail)
+      ),
+      preWarmedContext,
+      evalTokens,
+      ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+      evalLlmMs,
+      lastResultText: issueLines.join("\n\n"),
+      isEvalFeedback: true,
+      lastDiffFailed: false
+    };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error("[simple] eval failed:", message);
+    evalResult = evalResult ?? {
+      issues: [],
+      pass: [],
+      criteriaCoverage: notApplicableCoverage(`${EVAL_ROUND_THREW_REASON}: ${message}`),
+      runtimeProbe: { status: "infra-skipped", reason: `${EVAL_ROUND_THREW_REASON}: ${message}` }
+    };
+    return {
+      control: "break",
+      evalDone: false,
+      evalResult,
+      evalRoundsUsed,
+      prevModeSubcats,
+      prevFailFingerprints,
+      preWarmedContext,
+      evalTokens,
+      ...inLoopVisualTokens !== void 0 ? { inLoopVisualTokens } : {},
+      evalLlmMs,
+      lastResultText: "",
+      isEvalFeedback: false,
+      lastDiffFailed: false
+    };
+  }
+}
+
+// src/harness/coding/generate-task-runner.ts
+function createTelemetry() {
+  return {
+    counters: {
+      phases: { impl: 0, patch: 0, evalFix: 0, scaffold: 0, fill: 0 },
+      outcomes: { pass: 0, patchInvalid: 0, selfCheckFail: 0, diffFail: 0 }
+    },
+    turnsUsed: 0,
+    evalRoundsUsed: 0,
+    cumulativeLlmMs: 0,
+    cumulativeToolMs: 0,
+    cumulativeEvalWallMs: 0,
+    cumulativeEvalLlmMs: 0,
+    totalIn: 0,
+    totalOut: 0,
+    evalResult: void 0,
+    probeRepairUsed: false,
+    probeRepairTrigger: void 0,
+    contractFeedback: void 0,
+    sameExchangeBreak: void 0,
+    sameFailureBreak: void 0,
+    compiledCode: "",
+    pairedSource: "",
+    selfCheckPassed: false,
+    initialResultDelivered: false,
+    codingStartedAtMs: 0,
+    codingMs: 0
+  };
+}
+function absorbTokens(telemetry, usage) {
+  telemetry.totalIn += usage.input;
+  telemetry.totalOut += usage.output;
+  if (usage.cacheRead !== void 0) {
+    telemetry.cacheReadTokens = (telemetry.cacheReadTokens ?? 0) + usage.cacheRead;
+  }
+  if (usage.cacheCreation !== void 0) {
+    telemetry.cacheCreationTokens = (telemetry.cacheCreationTokens ?? 0) + usage.cacheCreation;
+  }
+}
+function absorbInLoopVisualTokens(telemetry, part) {
+  if (part === void 0) return;
+  const prev = telemetry.inLoopVisualTokens;
+  const prevCriteria = prev?.criteria;
+  const criteria = part.criteria === void 0 ? prevCriteria : {
+    inputTokens: (prevCriteria?.inputTokens ?? 0) + part.criteria.inputTokens,
+    outputTokens: (prevCriteria?.outputTokens ?? 0) + part.criteria.outputTokens
+  };
+  telemetry.inLoopVisualTokens = {
+    inputTokens: (prev?.inputTokens ?? 0) + part.inputTokens,
+    outputTokens: (prev?.outputTokens ?? 0) + part.outputTokens,
+    ...criteria !== void 0 ? { criteria } : {}
+  };
+}
+function absorbTurn(telemetry, turn) {
+  absorbTokens(telemetry, {
+    input: turn.tokens.input,
+    output: turn.tokens.output,
+    ...turn.cacheReadTokens !== void 0 ? { cacheRead: turn.cacheReadTokens } : {},
+    ...turn.cacheCreationTokens !== void 0 ? { cacheCreation: turn.cacheCreationTokens } : {}
+  });
+  telemetry.cumulativeLlmMs += turn.llmMs;
+  telemetry.cumulativeToolMs += turn.toolMs;
+  if (turn.phase) {
+    if (turn.phase === "scaffold") telemetry.counters.phases.scaffold++;
+    else if (turn.phase === "fill") telemetry.counters.phases.fill++;
+    else if (turn.phase === "impl") telemetry.counters.phases.impl++;
+    else if (turn.phase === "eval-fix") telemetry.counters.phases.evalFix++;
+    else telemetry.counters.phases.patch++;
+  }
+  if (turn.outcome) {
+    if (turn.outcome === "PASS") telemetry.counters.outcomes.pass++;
+    else if (turn.outcome === "PATCH_INVALID") telemetry.counters.outcomes.patchInvalid++;
+    else if (turn.outcome === "DIFF_FAIL") telemetry.counters.outcomes.diffFail++;
+    else telemetry.counters.outcomes.selfCheckFail++;
+  }
+  if (turn.sameExchangeBreak !== void 0) telemetry.sameExchangeBreak = turn.sameExchangeBreak;
+  if (turn.sameFailureBreak !== void 0) telemetry.sameFailureBreak = turn.sameFailureBreak;
+}
+function createGenerateTaskRunner(input) {
+  const { session, params, classification, telemetry } = input;
+  const maxTurns = input.maxTurns ?? 30;
+  const a1Mode = session.harness.process.mode === "staged";
+  let a1Phase = a1Mode ? "scaffold" : "post";
+  let lastResultText = "";
+  let lastDiffFailed = false;
+  let isEvalFeedback = false;
+  let iconNamesCache = null;
+  let preWarmedContext;
+  let prevModeSubcats = /* @__PURE__ */ new Set();
+  let prevFailFingerprints = /* @__PURE__ */ new Set();
+  let evalDone = false;
+  return async function generate(_task, _ctx) {
+    if (telemetry.codingStartedAtMs === 0) {
+      telemetry.codingStartedAtMs = Date.now();
+      params.onProgress?.({ type: "generating", phase: "coding" });
+    }
+    do {
+      telemetry.turnsUsed++;
+      const turn = await runCodingTurn(
+        {
+          workspace: session.workspace,
+          codingAgent: session.codingAgent,
+          codingModel: session.agents.coding.model,
+          systemPrompt: session.systemPrompt,
+          harness: session.harness,
+          contract: params.contract,
+          originalPrompt: params.userPrompt,
+          commitMeta: session.commitMeta,
+          originalProps: session.originalProps,
+          // ggui#1285: the fixture the probe and judge render with, for the echo check at auto-commit.
+          ...params.fixtureProps !== void 0 ? { fixtureProps: params.fixtureProps } : {},
+          costTracker: session.costTracker,
+          // Thread the dispatch-resolved policy so experimental
+          // profiles take effect on both preflight and tier-0 retry
+          // feedback.
+          contextPolicy: session.resolvedPolicy.context,
+          // Dupe-break state is mutable; runCodingTurn updates it in
+          // place (fingerprint + cooldown + forceEscape +
+          // scopedEscapeUsedCount).
+          dupeBreak: session.dupeBreak,
+          ...params.onCodingTurnPrompt !== void 0 ? { onPrompt: params.onCodingTurnPrompt } : {}
+        },
+        {
+          turnsUsed: telemetry.turnsUsed,
+          a1Phase,
+          lastResultText,
+          lastDiffFailed,
+          isEvalFeedback,
+          iconNamesCache,
+          preWarmedContext,
+          preWarmPromise: session.preWarmPromise
+        }
+      );
+      absorbTurn(telemetry, turn);
+      iconNamesCache = turn.iconNamesCache;
+      preWarmedContext = turn.preWarmedContext;
+      if (turn.control !== "proceed" && session.probeOnlyEnabled && telemetry.probeRepairUsed) {
+        if (telemetry.evalResult !== void 0) {
+          telemetry.evalResult = { ...telemetry.evalResult, runtimeProbeRepair: { attempted: true, compiled: false } };
+        }
+        console.log(
+          `[simple] probe-only repair turn did not compile (${turn.outcome ?? "no tool call"}) \u2014 serving the pre-repair card`
+        );
+        break;
+      }
+      if (turn.control === "break") break;
+      if (turn.control === "continue") {
+        lastResultText = turn.lastResultText;
+        lastDiffFailed = turn.lastDiffFailed;
+        isEvalFeedback = turn.isEvalFeedback;
+        continue;
+      }
+      telemetry.compiledCode = turn.compiledCode;
+      telemetry.pairedSource = session.workspace.read() ?? "";
+      telemetry.selfCheckPassed = turn.selfCheckPassed;
+      if (a1Mode && a1Phase === "scaffold" && telemetry.selfCheckPassed && telemetry.compiledCode) {
+        console.log(
+          `[simple] A1: scaffold compiled (${telemetry.compiledCode.length}B, turns=${telemetry.turnsUsed}) \u2192 entering fill phase`
+        );
+        a1Phase = "fill";
+        telemetry.selfCheckPassed = false;
+        telemetry.compiledCode = "";
+        telemetry.pairedSource = "";
+        lastResultText = "";
+        isEvalFeedback = false;
+        continue;
+      }
+      if (a1Mode && a1Phase === "fill" && telemetry.selfCheckPassed) {
+        console.log(`[simple] A1: fill completed (turns=${telemetry.turnsUsed}) \u2192 post phase`);
+        a1Phase = "post";
+      }
+      if (!telemetry.initialResultDelivered && telemetry.compiledCode) {
+        const sourceCode = session.workspace.read() ?? "";
+        console.log(`[simple] compiled: ${telemetry.compiledCode.length}B`);
+        if (params.onInitialResult) {
+          await params.onInitialResult({ componentCode: telemetry.compiledCode, sourceCode });
+        }
+        telemetry.initialResultDelivered = true;
+        const codingDoneMs = Date.now() - telemetry.codingStartedAtMs;
+        console.log(
+          `[simple] initial result delivered | ${codingDoneMs}ms | turns=${telemetry.turnsUsed} | tokens=${telemetry.totalIn + telemetry.totalOut} | compiled=${telemetry.compiledCode.length}B`
+        );
+      }
+      if (!evalDone && telemetry.compiledCode && (session.tiersMod && (session.codeEvalEnabled || session.visualEvalEnabled) || session.probeOnlyEnabled)) {
+        const evalRoundStart = Date.now();
+        const round = await runEvalRound(
+          {
+            workspace: session.workspace,
+            harness: session.harness,
+            contract: params.contract,
+            userPrompt: params.userPrompt,
+            fixtureProps: params.fixtureProps,
+            classification,
+            evaluationAgent: session.agents.evaluation,
+            visualEvalAgent: session.agents.visualEval,
+            visualEvaluation: params.visualEvaluation,
+            shellType: params.shellType,
+            visualThreshold: session.visualThreshold,
+            qualityMode: session.qualityMode,
+            maxEvalRounds: session.maxEvalRounds,
+            costTracker: session.costTracker,
+            llmEvalMod: session.llmEvalMod,
+            visualMod: session.visualMod,
+            preWarmPromise: session.preWarmPromise,
+            onProgress: params.onProgress,
+            probeOnly: session.probeOnlyEnabled,
+            probeRepairUsed: telemetry.probeRepairUsed,
+            ...telemetry.probeRepairTrigger !== void 0 ? { probeRepairTrigger: telemetry.probeRepairTrigger } : {}
+          },
+          {
+            compiledCode: telemetry.compiledCode,
+            evalRoundsUsed: telemetry.evalRoundsUsed,
+            preWarmedContext,
+            prevModeSubcats,
+            prevFailFingerprints
+          }
+        );
+        telemetry.cumulativeEvalWallMs += Date.now() - evalRoundStart;
+        telemetry.cumulativeEvalLlmMs += round.evalLlmMs;
+        telemetry.evalRoundsUsed = round.evalRoundsUsed;
+        prevModeSubcats = round.prevModeSubcats;
+        prevFailFingerprints = round.prevFailFingerprints;
+        preWarmedContext = round.preWarmedContext;
+        if (round.evalResult) telemetry.evalResult = round.evalResult;
+        if (round.contractFeedback) telemetry.contractFeedback = round.contractFeedback;
+        evalDone = round.evalDone;
+        absorbTokens(telemetry, round.evalTokens);
+        absorbInLoopVisualTokens(telemetry, round.inLoopVisualTokens);
+        if (round.control === "break") break;
+        if (session.probeOnlyEnabled) {
+          telemetry.probeRepairUsed = true;
+          telemetry.probeRepairTrigger = round.evalResult?.runtimeProbe;
+        }
+        lastResultText = round.lastResultText;
+        isEvalFeedback = round.isEvalFeedback;
+        lastDiffFailed = round.lastDiffFailed;
+      } else {
+        break;
+      }
+    } while (telemetry.turnsUsed < maxTurns && !evalDone);
+    if (session.probeOnlyEnabled && telemetry.probeRepairUsed && telemetry.evalResult !== void 0 && telemetry.evalResult.runtimeProbeRepair === void 0) {
+      console.log(`[simple] probe-only repair turn not taken \u2014 turn cap (${maxTurns}) reached before it`);
+    }
+    telemetry.codingMs = Date.now() - telemetry.codingStartedAtMs;
+    if (!telemetry.compiledCode) {
+      for (const [, meta] of session.commitMeta) {
+        if (meta.build.success && meta.selfCheck.passed && meta.build.compiledCode) {
+          telemetry.compiledCode = meta.build.compiledCode;
+          telemetry.selfCheckPassed = true;
+        }
+      }
+      if (!telemetry.compiledCode) {
+        for (const [, meta] of session.commitMeta) {
+          if (meta.build.success && meta.build.compiledCode) {
+            telemetry.compiledCode = meta.build.compiledCode;
+          }
+        }
+      }
+      if (telemetry.compiledCode && !telemetry.pairedSource) {
+        telemetry.pairedSource = session.workspace.read() ?? "";
+      }
+      console.log(`[simple] compiled (fallback): ${telemetry.compiledCode.length}B`);
+    }
+    if (!telemetry.initialResultDelivered && params.onInitialResult && telemetry.compiledCode) {
+      await params.onInitialResult({
+        componentCode: telemetry.compiledCode,
+        sourceCode: telemetry.pairedSource
+      });
+    }
+    return telemetry.pairedSource || (session.workspace.read() ?? "");
+  };
+}
+var FILE = "ui.tsx";
+var DIR = "/workspace";
+var FILEPATH = `${DIR}/${FILE}`;
+var AUTHOR = { name: "ggui-agent", email: "agent@ggui.ai" };
+var AgentWorkspace = class {
+  vol;
+  fs;
+  constructor() {
+    this.vol = new Volume();
+    this.fs = createFsFromVolume(this.vol);
+  }
+  async init() {
+    this.fs.mkdirSync(DIR, { recursive: true });
+    await git.init({ fs: this.fs, dir: DIR });
+  }
+  // ── File Operations ────────────────────────────────
+  read() {
+    try {
+      return this.fs.readFileSync(FILEPATH, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  write(code) {
+    this.fs.writeFileSync(FILEPATH, code);
+  }
+  cat(startLine, endLine) {
+    const content = this.read();
+    if (!content) return "(no file yet \u2014 use `write` to create it)";
+    const lines = content.split("\n");
+    const start = (startLine ?? 1) - 1;
+    const end = endLine ?? lines.length;
+    const padWidth = String(end).length;
+    return lines.slice(start, end).map((line, i) => `${String(start + i + 1).padStart(padWidth)}\u2502 ${line}`).join("\n");
+  }
+  grep(pattern, contextLines = 0) {
+    const content = this.read();
+    if (!content) return "(no file)";
+    const lines = content.split("\n");
+    const matchedIndices = /* @__PURE__ */ new Set();
+    const matchLines = /* @__PURE__ */ new Set();
+    for (let i = 0; i < lines.length; i++) {
+      if (new RegExp(pattern, "gi").test(lines[i])) {
+        matchLines.add(i);
+        for (let j = Math.max(0, i - contextLines); j <= Math.min(lines.length - 1, i + contextLines); j++) {
+          matchedIndices.add(j);
+        }
+      }
+    }
+    if (matchedIndices.size === 0) return "(no matches)";
+    const padWidth = String(lines.length).length;
+    return [...matchedIndices].sort((a, b) => a - b).map((i) => {
+      const prefix = matchLines.has(i) ? ">" : " ";
+      return `${prefix} ${String(i + 1).padStart(padWidth)}\u2502 ${lines[i]}`;
+    }).join("\n");
+  }
+  // ── Git Operations ─────────────────────────────────
+  async stage() {
+    await git.add({ fs: this.fs, dir: DIR, filepath: FILE });
+  }
+  async commit(message) {
+    await this.stage();
+    return git.commit({
+      fs: this.fs,
+      dir: DIR,
+      message,
+      author: AUTHOR
+    });
+  }
+  async log(depth) {
+    try {
+      return await git.log({ fs: this.fs, dir: DIR, depth: depth ?? 20 });
+    } catch {
+      return [];
+    }
+  }
+  async readFileAtCommit(oid) {
+    const { blob } = await git.readBlob({
+      fs: this.fs,
+      dir: DIR,
+      oid,
+      filepath: FILE
+    });
+    return new TextDecoder().decode(blob);
+  }
+  async checkout(oid) {
+    const content = await this.readFileAtCommit(oid);
+    this.write(content);
+  }
+  // ── Diff Operations ────────────────────────────────
+  async diffWorking() {
+    const commits = await this.log(1);
+    if (commits.length === 0) return "(no commits yet \u2014 new file)";
+    const committed = await this.readFileAtCommit(commits[0].oid);
+    const working = this.read() ?? "";
+    return createPatch(FILE, committed, working, "committed", "working", {
+      context: 3
+    });
+  }
+  async diffBetween(oldOid, newOid) {
+    const oldContent = await this.readFileAtCommit(oldOid);
+    const newContent = await this.readFileAtCommit(newOid);
+    return createPatch(
+      FILE,
+      oldContent,
+      newContent,
+      oldOid.slice(0, 7),
+      newOid.slice(0, 7),
+      { context: 3 }
+    );
+  }
+  applyDiff(patch) {
+    const current = this.read() ?? "";
+    if (!patch.includes("@@")) {
+      return {
+        success: false,
+        error: "Invalid diff format \u2014 missing @@ hunk headers. Use standard unified diff format."
+      };
+    }
+    const result = applyPatch(current, patch, {
+      fuzzFactor: 2,
+      compareLine: (_lineNum, line, _op, patchContent) => {
+        return line.trimEnd() === patchContent.trimEnd();
+      }
+    });
+    if (result === false) {
+      return {
+        success: false,
+        error: "Patch failed to apply \u2014 context lines in your diff do not match the current file. Re-read the current file provided in the prompt and produce a corrected diff."
+      };
+    }
+    this.write(result);
+    return { success: true };
+  }
+};
+
+// src/harness/in-loop-evaluation.ts
+function inLoopEvaluation(options) {
+  return {
+    text: options.evaluation?.enabled === true,
+    visual: options.visualEvaluation?.enabled === true || options.qualityConfig?.visualEval === true
+  };
+}
+function runsInLoopEvaluation(options) {
+  const legs = inLoopEvaluation(options);
+  return legs.text || legs.visual;
+}
+
+// src/harness/coding/init-session.ts
+function resolveSessionAgents(config) {
+  const coding = config.codingAgent;
+  const evaluation = config.evaluationAgent ?? coding;
+  const visualEval = config.visualEvalAgent ?? evaluation;
+  return { coding, evaluation, visualEval };
+}
+async function initSession(input) {
+  const { harness, params, agents } = input;
+  const resolvedPolicy = input.resolvedPolicy ?? harness.policy ?? DEFAULT_HARNESS_POLICY;
+  const startedAtMs = Date.now();
+  const boilerplate = harness.what.boilerplate;
+  console.log(
+    `[simple] boilerplate: ${boilerplate.split("\n").length} lines, shell=${params.shellType ?? "fullscreen"}, screen=${params.screen ?? "universal"}`
+  );
+  const workspace = new AgentWorkspace();
+  await workspace.init();
+  const commitMeta = /* @__PURE__ */ new Map();
+  workspace.write(boilerplate);
+  await workspace.stage();
+  await workspace.commit("scaffold: boilerplate");
+  const systemPrompt = input.systemPromptOverride ?? harness.how.systemPrompt;
+  const codingAgent = createAgent(agents.coding);
+  await codingAgent.warmCache(
+    agents.coding.model,
+    systemPrompt,
+    [APPLY_CHANGES_TOOL, GET_ICONS_TOOL],
+    "required"
+  );
+  const { text: codeEvalEnabled, visual: visualEvalEnabled } = inLoopEvaluation(params);
+  let preWarmPromise;
+  if (codeEvalEnabled) {
+    const evalSpec = agents.evaluation;
+    preWarmPromise = import('./llm-evaluator-PN3WFCS4.js').then(
+      (mod) => mod.preWarmEval(
+        {
+          sourceCode: "",
+          originalPrompt: params.userPrompt,
+          contract: params.contract,
+          designContext: void 0,
+          designMode: harness.designMode,
+          profile: harness.profile
+        },
+        {
+          provider: mapProviderForEvaluator(evalSpec.provider),
+          model: evalSpec.model
+        }
+      )
+    ).catch((e) => {
+      console.warn(`[simple] eval pre-warm failed: ${e instanceof Error ? e.message : e}`);
+      return null;
+    });
+  }
+  const propsMatch = boilerplate.match(/interface Props \{[\s\S]*?\n\}/);
+  const originalProps = propsMatch?.[0];
+  const qualityConfig = params.qualityConfig;
+  const qualityMode = qualityConfig?.quality ?? "fast";
+  const probeOnlyEnabled = harness.check.runtimeRender !== void 0 && !codeEvalEnabled && !visualEvalEnabled;
+  const maxEvalRounds = qualityMode === "high-quality" ? params.evaluation?.maxRounds ?? 3 : params.evaluation?.maxRounds ?? 2;
+  const visualThreshold = params.visualEvaluation?.passThreshold ?? 70;
+  let tiersMod = null;
+  let llmEvalMod = null;
+  let visualMod = null;
+  let costTracker = null;
+  if (codeEvalEnabled || visualEvalEnabled) {
+    tiersMod = await import('./check/index.js');
+    const costTrackerMod = await import('./cost-tracker-HHGQ4FTW.js');
+    costTracker = new costTrackerMod.CostTracker(
+      qualityConfig?.maxCostPerGeneration ?? null
+    );
+    if (codeEvalEnabled) {
+      llmEvalMod = await import('./llm-evaluator-PN3WFCS4.js');
+    }
+    if (visualEvalEnabled) {
+      visualMod = await import('./visual-evaluator-TGEXYQTP.js').catch(() => null);
+    }
+  }
+  return {
+    harness,
+    workspace,
+    codingAgent,
+    agents,
+    commitMeta,
+    boilerplate,
+    originalProps,
+    systemPrompt,
+    codeEvalEnabled,
+    visualEvalEnabled,
+    probeOnlyEnabled,
+    maxEvalRounds,
+    visualThreshold,
+    qualityMode,
+    tiersMod,
+    llmEvalMod,
+    visualMod,
+    costTracker,
+    preWarmPromise,
+    resolvedPolicy,
+    dupeBreak: createDupeBreakState(),
+    startedAtMs
+  };
+}
+
+// src/adapters/generation-dispatch.ts
+function mapProviderForLLMRouter(provider) {
+  return provider === "claude" ? "anthropic" : provider;
+}
+async function dispatchGeneration(params) {
+  if ((params.enableRuntimeRender ?? true) === true) {
+    void warmupRuntimeRenderProbe().catch(() => {
+    });
+  }
+  const routerProvider = mapProviderForLLMRouter(params.provider);
+  const resolvedModel = params.models?.coding ?? params.models?.default ?? params.model;
+  const codingAgent = {
+    provider: routerProvider,
+    model: resolvedModel,
+    routeOverride: params.routeOverride,
+    onRetry: params.onRetry
+  };
+  const evaluationAgent = params.models?.evaluation ? {
+    provider: routerProvider,
+    model: params.models.evaluation,
+    routeOverride: params.routeOverride,
+    onRetry: params.onRetry
+  } : void 0;
+  const visualEvalAgent = params.visualEvalAgent ? {
+    provider: params.visualEvalAgent.provider,
+    model: params.visualEvalAgent.model,
+    ...params.visualEvalAgent.apiKey !== void 0 ? { routeOverride: { apiKey: params.visualEvalAgent.apiKey } } : {},
+    onRetry: params.onRetry
+  } : void 0;
+  const effectiveContract = params.contract;
+  const sessionParams = {
+    userPrompt: params.originalPrompt ?? params.userPrompt,
+    contract: effectiveContract,
+    shellType: params.shellType,
+    screen: params.screen,
+    evaluation: params.evaluation ? {
+      enabled: params.evaluation.enabled,
+      passThreshold: params.evaluation.passThreshold,
+      maxRounds: params.evaluation.maxRounds ?? params.maxEvalRounds
+    } : void 0,
+    visualEvaluation: params.visualEvaluation,
+    qualityConfig: params.qualityConfig,
+    fixtureProps: params.fixtureProps,
+    ...params.onCodingTurnPrompt !== void 0 ? { onCodingTurnPrompt: params.onCodingTurnPrompt } : {}
+  };
+  const classification = classifyAxes({
+    contract: effectiveContract ?? {},
+    prompt: sessionParams.userPrompt
+  });
+  const harness = createHarness({
+    classification,
+    contract: effectiveContract ?? {},
+    prompt: sessionParams.userPrompt,
+    shellType: sessionParams.shellType,
+    screen: sessionParams.screen,
+    // Forward the registered catalog into createHarness so
+    // `generateBoilerplate` emits correct `import { useLeafletMap }
+    // from '<package>'` lines for thin contract refs. The closure
+    // capture below (systemPromptBuilder) wires the SAME catalog
+    // into the HOW leg.
+    ...params.appGadgets !== void 0 ? { appGadgets: params.appGadgets } : {},
+    // Forward the third-party wrapper `.d.ts` map so
+    // `WhatLeg.gadgetTypes` reaches the coding-agent's typecheck
+    // overlay (autoCommit → runTier0Checks → typecheck). The
+    // systemPromptBuilder closure below also captures `gadgetTypes`
+    // from `params` directly for the prompt `Type:` lines.
+    ...params.gadgetTypes !== void 0 ? { gadgetTypes: params.gadgetTypes } : {},
+    // Design mode + canvas — the harness carries them to every leg.
+    ...params.designMode !== void 0 ? { designMode: params.designMode } : {},
+    // ggui#1117 — the canvas is ALWAYS carried: a stated one, else the class
+    // shell × screen renders on. The axis checks judge for it
+    // (`universal.root_width_cap` stands down without one — which is what every
+    // served generation got, since the serving runtime states no canvas); the
+    // constrained prompt ignores it (INVARIANT 1, `design-mode.pin.test.ts`),
+    // so the prompt digests do not move; the free prompt renders it as before.
+    canvas: params.canvas ?? canvasForRendering(params.shellType, params.screen),
+    ...params.profile !== void 0 ? { profile: params.profile } : {},
+    // Policy is pre-resolved at the dispatch boundary so `createHarness`
+    // stays free of experiment plumbing. `resolveHarnessPolicy` applies
+    // the `GGUI_POLICY_PROFILE` experimental-profile layer and hands the
+    // result to the constructor.
+    policy: resolveHarnessPolicy(classification),
+    // Fully-populated system-prompt builder. This `buildSystemPrompt`
+    // wrapper pre-fills pitfalls + design-system docs + primitives +
+    // wire content.
+    //
+    // `appGadgets` is captured from `params` at dispatch time and
+    // threaded into the wrapper so the code-gen prompt's
+    // `clientCapabilities — registered catalog` section renders the
+    // operator-registered gadget set (Leaflet, Mapbox, …) instead of
+    // falling back to STDLIB. When omitted, the wrapper defaults to
+    // STDLIB-only.
+    // `params.gadgetTypes` is captured into the closure so the code-gen
+    // prompt's gadget catalog renders a `Type:` line per third-party
+    // gadget (the LLM sees a wrapper's real call shape it otherwise
+    // can't know).
+    systemPromptBuilder: ({
+      userRequest,
+      shellType,
+      screen,
+      axisDelta,
+      designMode,
+      canvas,
+      profile
+    }) => buildSystemPrompt(
+      userRequest,
+      shellType,
+      screen,
+      axisDelta,
+      params.appGadgets,
+      params.gadgetTypes,
+      designMode,
+      canvas,
+      profile
+    ),
+    // Pre-filtered axis-check registry. The `matches()` predicate
+    // selects the checks relevant to this generation's axis vector.
+    axisChecks: REGISTRY.filter(
+      (check) => matches(classification.vector, check)
+    ),
+    // The runtime-render check, built under the caller's probe config.
+    // Heavy deps (happy-dom + wire + design) stay on the dispatch side of
+    // the boundary; the skeleton createHarness defaults this to undefined.
+    //
+    // Gated behind `enableRuntimeRender` (default true) so
+    // benchmark/dev callers can opt out of in-loop probe execution and
+    // run the probe externally as a final post-generation check.
+    runtimeRender: params.enableRuntimeRender ?? true ? params.runtimeRender ?? DEFAULT_RUNTIME_RENDER_CHECK : void 0
+  });
+  console.log(
+    `[harness] id=${harness.id} name=${harness.name} workflow=${harness.process.workflow.name} overrides=${harness.meta.overrides.join(",") || "none"}`
+  );
+  console.log(
+    `[simple] axis-vector: ${JSON.stringify(classification.vector)} risk=${classification.riskTier}`
+  );
+  if (harness.process.workflow.name === "staged") {
+    throw new Error(
+      `[dispatch] STAGED workflow routed but architect/coder TaskRunners are not wired on the dispatch path. This is a misconfiguration (probably pickProcessMode returning WORKFLOWS.staged). For staged-like behaviour, set process.mode="staged" + workflow.name="single_pass" instead \u2014 the A1 scaffold\u2192fill phase machine lives inside the generate runner and fires without the workflow topology. See ralph #3 report (2026-04-14) for the full rationale.`
+    );
+  }
+  const agents = resolveSessionAgents({
+    codingAgent,
+    evaluationAgent,
+    ...visualEvalAgent !== void 0 ? { visualEvalAgent } : {}
+  });
+  const { resolveRunPolicyForProfile } = await import('./policy-VCYKGSAC.js');
+  const resolvedPolicy = resolveRunPolicyForProfile(process.env.GGUI_POLICY_PROFILE, harness, {
+    provider: routerProvider,
+    modelId: resolvedModel
+  });
+  let systemPromptOverride;
+  {
+    const { PRIMITIVES_DOCUMENTATION: PRIMITIVES_DOCUMENTATION2 } = await import('./validation/index.js');
+    const fullBytes = Buffer.byteLength(PRIMITIVES_DOCUMENTATION2, "utf8");
+    const docFormat = resolvedPolicy.context.primitiveDocFormat ?? "markdown";
+    const indexMode = resolvedPolicy.context.primitiveIndex ?? "off";
+    const mode = resolvedPolicy.context.primitiveDocSlice ?? "full";
+    let doc = PRIMITIVES_DOCUMENTATION2;
+    if (docFormat === "ts" && indexMode === "off") {
+      const { PRIMITIVES_DOCUMENTATION_TS } = await import('./tools/get-primitives-ts.js');
+      doc = PRIMITIVES_DOCUMENTATION_TS;
+      const tsBytes = Buffer.byteLength(doc, "utf8");
+      console.log(
+        `[simple] primitive-doc-ts-bytes=${tsBytes} baseline=${fullBytes} drop=${((1 - tsBytes / fullBytes) * 100).toFixed(1)}%`
+      );
+    }
+    const formatBytes = Buffer.byteLength(doc, "utf8");
+    if (mode === "axis-keyed" || mode === "axis-keyed+contract") {
+      const {
+        computePrimitiveAllowlist,
+        computeContractPrimitives,
+        slicePrimitiveDocumentation,
+        slicePrimitiveDocumentationTs
+      } = await import('./primitive-slice-WTMBLYFJ.js');
+      let allowlist = computePrimitiveAllowlist(classification);
+      if (mode === "axis-keyed+contract") {
+        const fromContract = computeContractPrimitives(effectiveContract);
+        allowlist = [.../* @__PURE__ */ new Set([...allowlist, ...fromContract])].sort();
+      }
+      const excludes = resolvedPolicy.context.primitiveDocExcludes ?? [];
+      if (excludes.length > 0) {
+        const excludeSet = new Set(excludes);
+        allowlist = allowlist.filter((p) => !excludeSet.has(p));
+      }
+      doc = docFormat === "ts" && indexMode === "off" ? slicePrimitiveDocumentationTs(doc, allowlist) : slicePrimitiveDocumentation(doc, allowlist);
+      const slicedBytes = Buffer.byteLength(doc, "utf8");
+      const excludeTag = excludes.length ? ` excludes=${excludes.join(",")}` : "";
+      console.log(
+        `[simple] primitive-doc-bytes=${slicedBytes} mode=${mode} baseline=${formatBytes} drop=${((1 - slicedBytes / formatBytes) * 100).toFixed(1)}% allowlist=${allowlist.length}/${allowlist.join(",")}${excludeTag}`
+      );
+    } else {
+      console.log(
+        `[simple] primitive-doc-bytes=${formatBytes} mode=full baseline=${formatBytes} drop=0.0%`
+      );
+    }
+    if (indexMode !== "off") {
+      const { buildPrimitiveIndex } = await import('./primitive-index-2OF6F4TZ.js');
+      doc = buildPrimitiveIndex(PRIMITIVES_DOCUMENTATION2, indexMode);
+      const indexBytes = Buffer.byteLength(doc, "utf8");
+      console.log(
+        `[simple] primitive-index-bytes=${indexBytes} mode=${indexMode} baseline=${fullBytes} drop=${((1 - indexBytes / fullBytes) * 100).toFixed(1)}%`
+      );
+    }
+    if (doc !== PRIMITIVES_DOCUMENTATION2) {
+      systemPromptOverride = harness.how.systemPrompt.replace(PRIMITIVES_DOCUMENTATION2, doc);
+    }
+    const sentPrompt = systemPromptOverride ?? harness.how.systemPrompt;
+    console.log(
+      `[simple] system-prompt-bytes=${Buffer.byteLength(sentPrompt, "utf8")} doc-format=${docFormat === "ts" && indexMode === "off" ? "ts" : docFormat} doc-bytes=${Buffer.byteLength(doc, "utf8")} mode=${indexMode !== "off" ? `index:${indexMode}` : mode}`
+    );
+    if (resolvedPolicy.context.planFirstTurn) {
+      const phaseGuidance = `
+
+## Generation Phases
+
+This generation runs in TWO phases:
+
+**Turn 1 \u2014 PLAN.** The harness only advertises the \`write_plan\` tool. Commit to:
+  \u2022 \`components\`: which primitives/components you will use (from the reference above).
+  \u2022 \`structure\`: a brief JSX outline showing nesting.
+  \u2022 \`wiring\`: state/actions/streams you will use.
+Do NOT attempt to write code \u2014 \`apply_changes\` is not available on turn 1.
+
+**Turn 2+ \u2014 EXECUTE.** Now write code via \`apply_changes\`. If your patches accumulate into a tangled broken state, \`rewrite\` is available as an escape. There is no fetch tool \u2014 the component reference above is complete.
+
+Your plan is a commitment, not a design doc. Keep it tight. Do not over-plan; just enough to pick components and sketch structure before writing.`;
+      systemPromptOverride = (systemPromptOverride ?? harness.how.systemPrompt) + phaseGuidance;
+      console.log(`[simple] plan-first-turn=on`);
+    }
+  }
+  const session = await initSession({
+    harness,
+    params: sessionParams,
+    agents,
+    resolvedPolicy,
+    systemPromptOverride
+  });
+  const telemetry = createTelemetry();
+  const generate = createGenerateTaskRunner({
+    session,
+    params: sessionParams,
+    classification,
+    telemetry,
+    maxTurns: params.maxAttempts ?? 8
+  });
+  const runResult = await runHarness({
+    harness,
+    prompt: sessionParams.userPrompt,
+    contract: params.contract ?? { intent: "" },
+    taskRunners: { generate },
+    compile: async () => telemetry.compiledCode || null,
+    passes: () => true,
+    skipCheck: true,
+    maxIterations: 1
+  });
+  if (!runResult.ok) {
+    console.error(
+      `[dispatch] runHarness terminated: ${runResult.reason} (source=${runResult.finalSource ? runResult.finalSource.length + "B" : "null"}, compiled=${runResult.finalCompiled ? runResult.finalCompiled.length + "B" : "null"})`
+    );
+  }
+  const finalSource = runResult.finalSource ?? "";
+  const result = await assembleGenerationResult({
+    session,
+    telemetry,
+    source: finalSource
+  });
+  return withArmRecord(result, params);
+}
+function withArmRecord(result, params) {
+  const recordedCanvas = params.canvas ?? (params.designMode === "free" ? canvasForRendering(params.shellType, params.screen) : void 0);
+  return {
+    ...result,
+    ...params.designMode !== void 0 ? { designMode: params.designMode } : {},
+    ...recordedCanvas !== void 0 ? { canvas: recordedCanvas } : {}
+  };
+}
+
+export { dispatchGeneration, inLoopEvaluation, runsInLoopEvaluation };
+//# sourceMappingURL=chunk-R5GIGPW2.js.map
+//# sourceMappingURL=chunk-R5GIGPW2.js.map