@ggui-ai/ui-gen 0.21.0 → 0.23.0

package/src/evaluation/visual-evaluator.ts

@@ -19,7 +19,7 @@ import { judgeDesignIdentity, type JudgeDesignIdentity } from './design-identity
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'node:module';
-import { existsSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
+import { existsSync, writeFileSync, mkdtempSync, rmSync } from 'fs';
 import { createHash } from 'node:crypto';
 import { tmpdir } from 'os';
 import { createVisionAgent, type AgentConfig } from '../harness/llm-router';
@@ -346,9 +346,12 @@ async function bundleForRendering(
   sampleProps: Record<string, unknown>,
   designSrc: string = resolve(resolveDesignPackageDir(), 'src'),
 ): Promise<string> {
-  // Write component + entry to temp files for esbuild
-  const tmpDir = resolve(tmpdir(), 'ggui-visual-eval-' + Date.now());
-  mkdirSync(tmpDir, { recursive: true });
+  // Write component + entry to temp files for esbuild — in a directory of THIS
+  // call's own. `mkdtempSync` is atomic and unique: a timestamp-named directory
+  // was shared by two bundles started in the same millisecond, so the first
+  // build read the second's component (a judge scoring the wrong generation)
+  // and the first's cleanup deleted the files the second was building.
+  const tmpDir = mkdtempSync(resolve(tmpdir(), 'ggui-visual-eval-'));
   const componentFile = resolve(tmpDir, 'component.tsx');
   const entryFile = resolve(tmpDir, 'entry.tsx');
 
@@ -439,8 +442,8 @@ try {
 
     return result.outputFiles[0]?.text ?? '';
   } finally {
-    try { unlinkSync(entryFile); } catch { /* cleanup */ }
-    try { unlinkSync(componentFile); } catch { /* cleanup */ }
+    // The whole per-call directory; `force` makes an already-absent path a no-op.
+    rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 

package/src/generator-build.ts

@@ -0,0 +1,158 @@
+/**
+ * The generator's BUILD identity (ggui#1280): values that change when the
+ * triad's templates change and never with the request, so generations group
+ * by the build that produced them.
+ *
+ * - `promptTemplateSha256` / `boilerplateTemplateSha256` are sha256 over the
+ *   production system prompt and the boilerplate rendered on the design-mode
+ *   pin's FIXED fixtures (`PIN_FIXTURES`), in the live env, so an env-gated
+ *   block (the pitfalls) counts as it really is. The design-mode pin renders
+ *   the same functions and asserts these values equal its recorded constants
+ *   under the default env: the runtime key and the pin cannot drift.
+ * - These are BUILD keys, not instance fingerprints. A hash of the prompt one
+ *   generation actually sent embeds the request and differs every time, so it
+ *   could never group two generations by build.
+ * - `version` is the package's own version, read once from the nearest
+ *   `package.json` named `@ggui-ai/ui-gen` above this module. It is absent
+ *   when none is found (e.g. a consumer bundled this package into one file),
+ *   never guessed.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { GeneratorBuild } from '@ggui-ai/mcp-server-core';
+import { generateBoilerplate } from './boilerplate/generate.js';
+import type { DesignMode } from './design-mode.js';
+import { buildSystemPrompt } from './harness/runtime.js';
+import { PIN_FIXTURES } from './pin-fixtures.js';
+
+/** The separator the rendered fixtures are joined with before hashing. */
+export const TEMPLATE_FIXTURE_BOUNDARY = '\n<<<pin-fixture-boundary>>>\n';
+
+/** sha256 hex of a rendered template. */
+export function templateSha256(text: string): string {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+/**
+ * The production system prompt for every pin fixture, joined. The constrained
+ * arm uses the positional default-path signature (no `designMode` argument),
+ * which is what the pin has always recorded.
+ */
+export function renderPromptTemplates(designMode: DesignMode): string {
+  return PIN_FIXTURES.map((f) => {
+    switch (designMode) {
+      case 'constrained':
+        return buildSystemPrompt(f.userRequest, f.shellType, f.screen);
+      case 'free':
+        return buildSystemPrompt(f.userRequest, f.shellType, f.screen, undefined, undefined, undefined, 'free');
+    }
+  }).join(TEMPLATE_FIXTURE_BOUNDARY);
+}
+
+/** The boilerplate for every pin fixture, joined — same signature split as the prompt. */
+export function renderBoilerplateTemplates(designMode: DesignMode): string {
+  return PIN_FIXTURES.map((f) => {
+    switch (designMode) {
+      case 'constrained':
+        return generateBoilerplate(f.userRequest, f.contract, f.shellType, f.screen);
+      case 'free':
+        return generateBoilerplate(f.userRequest, f.contract, f.shellType, f.screen, undefined, undefined, 'free');
+    }
+  }).join(TEMPLATE_FIXTURE_BOUNDARY);
+}
+
+/**
+ * ui-gen's precise {@link GeneratorBuild}: the core port's generic shape with
+ * ui-gen's own keys — `mode` is the design mode, and `digests` names the two
+ * template digests (the keys a blueprint's build stamp copies).
+ */
+export interface UiGenBuild extends GeneratorBuild {
+  /** This package's version; absent when its `package.json` cannot be found at runtime. */
+  readonly version?: string;
+  readonly mode: DesignMode;
+  readonly digests: {
+    readonly promptTemplateSha256: string;
+    readonly boilerplateTemplateSha256: string;
+  };
+}
+
+const PACKAGE_NAME = '@ggui-ai/ui-gen';
+/** How far up from this module the package root can sit (`src/`, `dist/`, a nested entry). */
+const MAX_PACKAGE_DEPTH = 6;
+
+/**
+ * A `package.json` the walk meets may not be ours, and in a consumer's bundle
+ * it may not even parse. A candidate that does not parse is skipped (as if
+ * absent), so reading this package's version can never fail a generation —
+ * the version is then absent, never guessed. Only a JSON `SyntaxError` is
+ * handled here; any other error is a real fault and propagates.
+ */
+function parsePackageJson(text: string): unknown {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed;
+  } catch (err) {
+    if (err instanceof SyntaxError) return undefined;
+    throw err;
+  }
+}
+
+/**
+ * Walk up from `startDir` (this module's own directory by default) to the
+ * nearest `package.json` named `@ggui-ai/ui-gen` and return its version;
+ * `undefined` when none is found within reach.
+ */
+export function findPackageVersion(startDir: string = dirname(fileURLToPath(import.meta.url))): string | undefined {
+  let dir = startDir;
+  for (let i = 0; i < MAX_PACKAGE_DEPTH; i++) {
+    const candidate = join(dir, 'package.json');
+    const pkg = existsSync(candidate) ? parsePackageJson(readFileSync(candidate, 'utf8')) : undefined;
+    if (pkg !== undefined) {
+      if (
+        typeof pkg === 'object' &&
+        pkg !== null &&
+        'name' in pkg &&
+        pkg.name === PACKAGE_NAME &&
+        'version' in pkg &&
+        typeof pkg.version === 'string'
+      ) {
+        return pkg.version;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return undefined;
+}
+
+let versionRead = false;
+let packageVersion: string | undefined;
+const identities = new Map<string, UiGenBuild>();
+
+/**
+ * The build identity for `designMode`, computed once per process per design
+ * mode and pitfalls env gate (the only env the templates read), so a changed
+ * gate is never answered from a stale memo.
+ */
+export function generatorBuild(designMode: DesignMode): UiGenBuild {
+  const key = `${designMode}|${process.env.GGUI_PITFALLS ?? ''}|${process.env.GGUI_NEW_PITFALLS ?? ''}`;
+  const known = identities.get(key);
+  if (known !== undefined) return known;
+  if (!versionRead) {
+    packageVersion = findPackageVersion();
+    versionRead = true;
+  }
+  const identity: UiGenBuild = {
+    ...(packageVersion !== undefined ? { version: packageVersion } : {}),
+    mode: designMode,
+    digests: {
+      promptTemplateSha256: templateSha256(renderPromptTemplates(designMode)),
+      boilerplateTemplateSha256: templateSha256(renderBoilerplateTemplates(designMode)),
+    },
+  };
+  identities.set(key, identity);
+  return identity;
+}

package/src/harness/check/runtime-render/adapter.ts

@@ -54,11 +54,30 @@ export const DEFAULT_RUNTIME_RENDER_CHECK: RuntimeRenderCheck = {
       return { status: "infra-skipped", issues: [], reason: message };
     }
 
+    const hostLoad = result.stats.hostLoad;
+    const load = hostLoad !== undefined ? { hostLoad } : {};
+
+    // ggui#1299: a check that ran out of wall-clock time is not a verdict on
+    // the component. It becomes the `timed-out` status (did-not-run, never a
+    // pass, never a crash), never an eval issue — so the coding agent is never
+    // told to fix a crash that did not happen.
+    if (result.incomplete !== undefined) {
+      const { elapsedMs, boundMs } = result.incomplete;
+      const loadNote =
+        hostLoad !== undefined
+          ? `; host load ${hostLoad.start.toFixed(1)} → ${hostLoad.end.toFixed(1)} on ${hostLoad.cores} CPUs`
+          : "";
+      const reason = `render check did not finish within ${boundMs} ms (stopped at ${elapsedMs} ms)${loadNote}`;
+      console.warn(`[runtime-render] probe timed out — ${reason}`);
+      return { status: "timed-out", issues: [], reason, elapsedMs, ...load };
+    }
+
     return {
       status: "ran",
       issues: result.issues
         .map(toEvalIssue)
         .filter((x): x is EvalIssue => x !== null),
+      ...load,
     };
   },
 };

package/src/harness/check/runtime-render/render-check-host.ts

@@ -11,13 +11,24 @@
  * `unverified`, and nothing throws):
  *
  *   - worker exit 0 + parseable verdict → the verdict, verbatim.
- *   - timeout                    → `failed` (runaway component: the
- *     in-process check has no comparable wall-clock bound, the
- *     subprocess finally gives us one).
- *   - spawn-error / overflow / non-zero exit / unparseable stdout
+ *   - timeout                    → `incomplete` (ggui#1299): the check
+ *     did not finish, which is NOT a verdict on the component. The bound
+ *     is wall-clock, and on a contended host an ordinary component
+ *     crosses it; mapping it to `failed` reported crashes that never
+ *     happened. It carries its elapsed ms, and the host load (below)
+ *     says how busy the host was. React's own runaway guards ("Too many
+ *     re-renders", "Maximum update depth exceeded") throw, so they still
+ *     reach `render-no-throw` as `failed`; what now reads `incomplete`
+ *     is a check that ran out of wall-clock time, whatever the cause.
+ *   - overflow                   → `failed` (a pathological logging or
+ *     error loop; output volume does not depend on host load).
+ *   - spawn-error / non-zero exit / unparseable stdout
  *                                → `unverified` (the harness could not
  *     run the check; never blame the component for our plumbing).
  *
+ * Every isolated check records the host's 1-minute load average at its
+ * start and end, and the CPUs available, on `stats.hostLoad`.
+ *
  * Spawn resolution copies the proven `src/tools/render-check.ts`
  * pattern: prefer the built `dist/.../render-check-worker.js`; in
  * dev/test (vitest imports `src/`), fall back to `node --import tsx`
@@ -29,9 +40,11 @@
  */
 import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { availableParallelism, loadavg } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { runSandboxed } from '@ggui-ai/sandbox';
 import type { SandboxResult } from '@ggui-ai/sandbox';
+import type { ProbeHostLoad } from '../../../evaluation/types-public.js';
 import type { RenderCheckResult, RunRenderCheckInput } from './render-check.js';
 
 /**
@@ -121,10 +134,12 @@ export function mapSandboxResultToCheckResult(
   t0: number,
 ): RenderCheckResult {
   if (result.outcome === 'timeout') {
-    return failed(
-      `render check timed out after ${CHECK_TIMEOUT_MS}ms in the isolated worker (likely infinite loop or runaway effect in the component).`,
-      t0,
-    );
+    return {
+      ok: false,
+      issues: [],
+      incomplete: { kind: 'timeout', elapsedMs: result.durationMs, boundMs: CHECK_TIMEOUT_MS },
+      stats: { actionsChecked: 0, streamsChecked: 0, renderMs: Date.now() - t0 },
+    };
   }
   if (result.outcome === 'overflow-stdout' || result.outcome === 'overflow-stderr') {
     return failed(
@@ -184,6 +199,7 @@ export async function runRenderCheckViaWorker(
     return unverified(err instanceof Error ? err.message : String(err), t0);
   }
 
+  const loadAtStart = loadavg()[0] ?? 0;
   const result = await runSandboxed({
     command: spawn.command,
     args: spawn.args,
@@ -197,5 +213,11 @@ export async function runRenderCheckViaWorker(
     env: { NODE_ENV: process.env.NODE_ENV ?? 'production' },
   });
 
-  return mapSandboxResultToCheckResult(result, t0);
+  const hostLoad: ProbeHostLoad = {
+    start: loadAtStart,
+    end: loadavg()[0] ?? 0,
+    cores: availableParallelism(),
+  };
+  const mapped = mapSandboxResultToCheckResult(result, t0);
+  return { ...mapped, stats: { ...mapped.stats, hostLoad } };
 }

package/src/harness/check/runtime-render/render-check.ts

@@ -45,6 +45,7 @@ import {
   type ParentLink,
 } from "./host-boundary.js";
 import { hostGlobals, openRecord } from "../../../internal/open-record.js";
+import type { ProbeHostLoad } from "../../../evaluation/types-public.js";
 import { primeInputs } from "@ggui-ai/ui-visual-tester/prime-inputs";
 
 /**
@@ -118,13 +119,31 @@ export type InputPrimingDiagnostic =
   | { readonly primed: number }
   | { readonly error: string };
 
+/**
+ * The check started but did not finish (ggui#1299). The only kind is a
+ * wall-clock timeout in the isolated worker. It is not a verdict on the
+ * component: `issues` is empty and `ok` is false because nothing was
+ * verified, never because something failed.
+ */
+export interface RenderCheckIncomplete {
+  readonly kind: "timeout";
+  /** How long the worker ran before it was stopped. */
+  readonly elapsedMs: number;
+  /** The wall-clock bound it crossed. */
+  readonly boundMs: number;
+}
+
 export interface RenderCheckResult {
   readonly ok: boolean;
   readonly issues: readonly RenderCheckIssue[];
+  /** Present only when the check did not finish; see {@link RenderCheckIncomplete}. */
+  readonly incomplete?: RenderCheckIncomplete;
   readonly stats: {
     readonly actionsChecked: number;
     readonly streamsChecked: number;
     readonly renderMs: number;
+    /** Host load around an isolated check (absent in-process). */
+    readonly hostLoad?: ProbeHostLoad;
   };
 }
 

package/src/harness/claude-code-login-query.ts

@@ -43,7 +43,7 @@ import { z } from "zod";
 import type { LLMToolDef } from "../llm.js";
 import {
   claudeCodeLoginQueryOptions,
-  stripProviderKeyEnv,
+  loginChildEnv,
 } from "../adapters/claude/claude-code-login.js";
 import { MCP_SERVER_NAME } from "../adapters/claude/tool-bridge.js";
 import { toolArgsToJsonObject } from "../adapters/tool-bridge.js";
@@ -186,8 +186,9 @@ export async function* imageUserMessage(
  * SDK's typed `thinking` option (the probe spelled it `thinkingConfig`,
  * untyped, and saw a thinking block anyway — whether the typed spelling
  * is honoured is Exp 009's to measure; it reports thinking tokens as
- * their own column either way); every provider key name is stripped from the
- * env the binary inherits; Layer 1's pins keep it tool-less (the CLI's
+ * their own column either way); the binary inherits an allowlisted env
+ * (`loginChildEnv`: no provider key, nothing else the parent merely holds,
+ * ggui#1278); Layer 1's pins keep it tool-less (the CLI's
  * own tools), config-less (`~/.claude` never loads) and non-bare (the
  * login store IS read). Tools, when offered, come as ggui's in-process
  * MCP server with NO allow-list and the denying intercept.
@@ -206,7 +207,7 @@ export function buildLoginQueryOptions(params: {
     systemPrompt: params.systemPrompt,
     maxTurns: 1,
     thinking: { type: "disabled" },
-    env: stripProviderKeyEnv(params.env ?? process.env),
+    env: loginChildEnv(params.env ?? process.env),
     ...claudeCodeLoginQueryOptions(),
     ...(params.tools !== undefined
       ? {

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

@@ -122,7 +122,14 @@ export async function assembleGenerationResult(
     generationTimeMs: totalMs,
     turnsUsed: telemetry.turnsUsed,
     passesUsed: 1,
-    evalResult: telemetry.evalResult,
+    // 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 !== undefined && telemetry.contractFeedback !== undefined
+        ? { ...telemetry.evalResult, contractFeedback: telemetry.contractFeedback }
+        : telemetry.evalResult,
+    // ggui#404 — present only when the same-exchange guard ended the run.
+    ...(telemetry.sameExchangeBreak !== undefined ? { sameExchangeBreak: telemetry.sameExchangeBreak } : {}),
     needsBackgroundImprovement,
     selfCheckPassed: telemetry.selfCheckPassed,
     timing,

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

@@ -12,7 +12,7 @@
 
 import type { Classification } from "../../classifier/index.js";
 import type { JsonValue } from "@ggui-ai/protocol";
-import type { EvalResult } from "../../evaluation/types-public.js";
+import type { ContractFeedbackRecord, EvalResult } from "../../evaluation/types-public.js";
 import type { Harness, Task, TaskContext } from "../types-public.js";
 import type { SingleComponentParams } from "../runtime.js";
 import type { TaskRunner } from "../index.js";
@@ -20,8 +20,11 @@ import type { CodingSession } from "./init-session.js";
 import {
   runCodingTurn,
   type A1Phase,
+  type CodingTurnResult,
 } from "./run-coding-turn.js";
 import { runEvalRound } from "./run-eval-round.js";
+import type { TokenUsage } from "./run-eval-round.js";
+import type { SameExchangeBreak } from "../result-types.js";
 
 type PreWarmedEvalContext =
   import("../../evaluation/llm-evaluator.js").PreWarmedEvalContext;
@@ -64,15 +67,27 @@ export interface GenerateTelemetry {
   /** Total output tokens billed across coding + eval. */
   totalOut: number;
   /**
-   * Prompt-cache tokens accumulated across coding turns, when the
-   * provider reports them. Optional: stays `undefined` for providers
-   * that don't expose cache accounting (never defaulted to 0 here, so
-   * the boundary can distinguish "no cache reads" from "unreported").
+   * Prompt-cache tokens accumulated across coding turns AND eval rounds
+   * (ggui#1281), when the provider reports them. Optional: stays
+   * `undefined` for providers that don't expose cache accounting (never
+   * defaulted to 0 here, so the boundary can distinguish "no cache reads"
+   * from "unreported").
    */
   cacheReadTokens?: number;
   cacheCreationTokens?: number;
   /** Latest evalResult — undefined when eval was disabled or never ran. */
   evalResult: EvalResult | undefined;
+  /**
+   * ggui#1261 — the contract-feedback round, once one fired: kept across the
+   * rounds after it (each rebuilds `evalResult`) so the assembled result can
+   * carry the round's before beside the source the generation ends with.
+   */
+  contractFeedback: ContractFeedbackRecord | undefined;
+  /**
+   * The same-exchange guard's record (ggui#404), set by the turn it ended —
+   * undefined unless that guard is what stopped the loop.
+   */
+  sameExchangeBreak: SameExchangeBreak | undefined;
   /** Latest compiled code — empty string until the first self-check pass. */
   compiledCode: string;
   /**
@@ -111,6 +126,8 @@ export function createTelemetry(): GenerateTelemetry {
     totalIn: 0,
     totalOut: 0,
     evalResult: undefined,
+    contractFeedback: undefined,
+    sameExchangeBreak: undefined,
     compiledCode: "",
     pairedSource: "",
     selfCheckPassed: false,
@@ -120,6 +137,56 @@ export function createTelemetry(): GenerateTelemetry {
   };
 }
 
+/**
+ * Fold one call's (or one eval round's) tokens into the run's totals — the ONE
+ * rule for coding turns and eval rounds alike (ggui#1281: the eval path used to
+ * add input/output only, so `tokens.total` dropped every eval call's cached
+ * prefix). A cache counter is seeded on its first report and stays `undefined`
+ * while nothing has reported one: unreported, never zero.
+ */
+export function absorbTokens(telemetry: GenerateTelemetry, usage: TokenUsage): void {
+  telemetry.totalIn += usage.input;
+  telemetry.totalOut += usage.output;
+  if (usage.cacheRead !== undefined) {
+    telemetry.cacheReadTokens = (telemetry.cacheReadTokens ?? 0) + usage.cacheRead;
+  }
+  if (usage.cacheCreation !== undefined) {
+    telemetry.cacheCreationTokens = (telemetry.cacheCreationTokens ?? 0) + usage.cacheCreation;
+  }
+}
+
+/**
+ * Fold one coding turn's measurements into the run's telemetry — tokens (via
+ * {@link absorbTokens}), timings, the phase/outcome counters, and the
+ * same-exchange guard's record when that guard ended the turn (ggui#404). One
+ * function so every per-turn fact the result is assembled from lands in one
+ * place.
+ */
+export function absorbTurn(telemetry: GenerateTelemetry, turn: CodingTurnResult): void {
+  absorbTokens(telemetry, {
+    input: turn.tokens.input,
+    output: turn.tokens.output,
+    ...(turn.cacheReadTokens !== undefined ? { cacheRead: turn.cacheReadTokens } : {}),
+    ...(turn.cacheCreationTokens !== undefined ? { 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 !== undefined) telemetry.sameExchangeBreak = turn.sameExchangeBreak;
+}
+
 export interface CreateGenerateRunnerInput {
   readonly session: CodingSession;
   readonly params: SingleComponentParams;
@@ -203,38 +270,10 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
         },
       );
 
-      telemetry.totalIn += turn.tokens.input;
-      telemetry.totalOut += turn.tokens.output;
-      // Accumulate prompt-cache counters only when the provider reported
-      // them this turn. Seeding from `undefined` on first report keeps the
-      // "unreported" providers' totals absent rather than 0.
-      if (turn.cacheReadTokens !== undefined) {
-        telemetry.cacheReadTokens =
-          (telemetry.cacheReadTokens ?? 0) + turn.cacheReadTokens;
-      }
-      if (turn.cacheCreationTokens !== undefined) {
-        telemetry.cacheCreationTokens =
-          (telemetry.cacheCreationTokens ?? 0) + turn.cacheCreationTokens;
-      }
-      telemetry.cumulativeLlmMs += turn.llmMs;
-      telemetry.cumulativeToolMs += turn.toolMs;
+      absorbTurn(telemetry, turn);
       iconNamesCache = turn.iconNamesCache;
       preWarmedContext = turn.preWarmedContext;
 
-      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.control === "break") break;
       if (turn.control === "continue") {
         lastResultText = turn.lastResultText;
@@ -334,9 +373,9 @@ export function createGenerateTaskRunner(input: CreateGenerateRunnerInput): Task
         prevFailFingerprints = round.prevFailFingerprints;
         preWarmedContext = round.preWarmedContext;
         if (round.evalResult) telemetry.evalResult = round.evalResult;
+        if (round.contractFeedback) telemetry.contractFeedback = round.contractFeedback;
         evalDone = round.evalDone;
-        telemetry.totalIn += round.evalTokens.input;
-        telemetry.totalOut += round.evalTokens.output;
+        absorbTokens(telemetry, round.evalTokens);
 
         if (round.control === "break") break;
         // round.control === "feedback" — set next coding turn input.

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

@@ -21,6 +21,7 @@ import { executeTool } from "../../coding-agent/tools.js";
 import type { CostTracker } from "../../evaluation/cost-tracker.js";
 import type { LLMAgent } from "../llm-router.js";
 import type { Harness } from "../types-public.js";
+import type { SameExchangeBreak } from "../result-types.js";
 import {
   APPLY_CHANGES_HASHLINE_TOOL,
   APPLY_CHANGES_HASHLINE_TOOL_FLAT,
@@ -244,6 +245,12 @@ export interface CodingTurnResult {
   readonly isEvalFeedback: boolean;
   readonly iconNamesCache: string | null;
   readonly preWarmedContext: PreWarmedEvalContext | null | undefined;
+  /**
+   * Set only on the `break` the same-exchange guard returns (ggui#404) — the
+   * one way a caller can tell this guard ended the run, since `break` is a
+   * control value many exits share. No key on any other turn.
+   */
+  readonly sameExchangeBreak?: SameExchangeBreak;
 }
 
 /**
@@ -637,6 +644,7 @@ ${closingInstruction}`;
         isEvalFeedback: false,
         iconNamesCache,
         preWarmedContext,
+        sameExchangeBreak: { tool: call.name, repeats: iconRepeats },
       };
     }
     return {
@@ -964,6 +972,7 @@ ${closingInstruction}`;
       isEvalFeedback: false,
       iconNamesCache,
       preWarmedContext,
+      sameExchangeBreak: { tool: call.name, repeats: sameExchangeRepeats },
     };
   }