@vibes.diy/api-svc 14.3.91 → 14.3.93

package/intern/instant-build.js

@@ -5,11 +5,23 @@ import { createBlockStream, isCodeEnd, } from "@vibes.diy/call-ai-v2";
 import { lazyType } from "@vibes.diy/api-types/lazy-type";
 import { createBlockAccumulator, createStreamingResolver, resolveCodeBlocks } from "./prompt-streaming.js";
 import { synthesizeImports } from "./import-synth.js";
-import { checkOpens, OPENS_ADVISORY_CLASSES } from "./opens-check.js";
+import { checkOpens, collapseOpensFindings, newOpensFindings, opensBaseline, opensFindingKey, OPENS_ADVISORY_CLASSES, } from "./opens-check.js";
+import { fillDefect, gapLadder, identFill, intactnessDefect, mergeGaps, parseModule, regionFill, regionMessages, splice, } from "./repair-ladder.js";
 import { saveRepairFindings } from "./save-repair.js";
 import { composeRepairAsk, renderRepairFiles } from "./save-repair-io.js";
 import { createPromptAssetFetch, promptsPkgBaseUrl } from "./prompt-asset-fetch.js";
 import { loadActiveSettings, lookOptionForTurn } from "./prompt-assembly.js";
+import { MercuryCircuitBreaker } from "./mercury-resilience.js";
+export const INSTANT_MERCURY_FANOUT = 4;
+export const INSTANT_REPAIR_MODE = "router";
+export const INSTANT_LADDER_ROUNDS = 4;
+export const INSTANT_THROTTLED_ROUNDS_MAX = 6;
+export const INSTANT_REPAIR_ROWS_MAX = 24;
+export const INSTANT_REEMIT_CLASSES = new Set(["out-of-scope-identifier", "undefined-identifier"]);
+export function instantMercuryMaxAttempts(mode) {
+    return mode === "reemit" ? 3 : 1 + INSTANT_LADDER_ROUNDS + 1;
+}
+export const INSTANT_MERCURY_MAX_ATTEMPTS = instantMercuryMaxAttempts(INSTANT_REPAIR_MODE);
 export const INSTANT_MERCURY_MODEL = "inception/mercury-2.5";
 export const INSTANT_HAIKU_MODEL = "anthropic/claude-haiku-5.5";
 export const INSTANT_MAX_OUTPUT_TOKENS = 32_000;
@@ -17,6 +29,7 @@ export const INSTANT_MERCURY_CALL_MS = 40_000;
 export const INSTANT_HAIKU_CALL_MS = 90_000;
 export const INSTANT_STAGE_BUDGET_MS = 150_000;
 export const INSTANT_MAX_ATTEMPTS = 5;
+export const INSTANT_MERCURY_BREAKER = new MercuryCircuitBreaker();
 export function instantModelChoice(name) {
     switch (name) {
         case "mercury":
@@ -26,9 +39,16 @@ export function instantModelChoice(name) {
                 reasoning: { effort: "none" },
                 reasoningEffort: "none",
                 callMs: INSTANT_MERCURY_CALL_MS,
+                maxAttempts: INSTANT_MERCURY_MAX_ATTEMPTS,
             };
         case "haiku":
-            return { name, id: INSTANT_HAIKU_MODEL, reasoning: { enabled: false }, callMs: INSTANT_HAIKU_CALL_MS };
+            return {
+                name,
+                id: INSTANT_HAIKU_MODEL,
+                reasoning: { enabled: false },
+                callMs: INSTANT_HAIKU_CALL_MS,
+                maxAttempts: INSTANT_MAX_ATTEMPTS,
+            };
     }
 }
 export const INSTANT_PARAGRAPH = "Build the interaction this sentence names, fully working, with realistic launch content. " +
@@ -149,11 +169,23 @@ export function autofixAndCheck(args) {
     const fixed = synthesizeImports({ vfs: args.vfs, paths: args.changed.filter((path) => args.vfs.has(path)), look: args.look });
     const files = [...fixed.vfs].map(([filename, content]) => ({ type: "code-block", filename, lang: "jsx", content }));
     const parse = saveRepairFindings(files, new Set(args.changed)).map((finding) => `${finding.path.replace(/^\/+/, "")}: ${finding.message}`);
-    const opens = checkOpens(fixed.vfs)
-        .findings.filter((finding) => OPENS_ADVISORY_CLASSES.has(finding.class) === false)
-        .map((finding) => `${finding.file.replace(/^\/+/, "")}:${finding.line}: ${finding.message}`);
+    const verdict = checkOpens(fixed.vfs);
+    const blocking = newOpensFindings(verdict, args.baseline ?? new Set());
+    const line = (finding) => `${finding.file.replace(/^\/+/, "")}:${finding.line}: ${finding.message}`;
+    const opens = collapseOpensFindings(blocking).map(line);
+    const advisory = verdict.findings
+        .filter((finding) => OPENS_ADVISORY_CLASSES.has(finding.class) === false && blocking.includes(finding) === false)
+        .map(line);
     const findings = [...parse, ...opens];
-    return { vfs: fixed.vfs, opens: findings.length === 0, findings, notes: fixed.notes };
+    return {
+        vfs: fixed.vfs,
+        opens: findings.length === 0,
+        findings,
+        blocking,
+        unlocated: parse.length,
+        advisory,
+        notes: fixed.notes,
+    };
 }
 const completionBody = lazyType(() => type({
     "model?": "string",
@@ -212,6 +244,13 @@ export function instantModelCallFor(vctx) {
         });
     };
 }
+function isThrottle(error) {
+    return /\bstatus 429\b/.test(error.message);
+}
+function throttleWaitMs(n, random) {
+    const exp = Math.min(8_000, 1_000 * 2 ** Math.max(0, n - 1));
+    return Math.round(exp / 2 + random() * (exp / 2));
+}
 async function callWithin(call, req, cancel) {
     const abort = new AbortController();
     const timer = setTimeout(function expire() {
@@ -255,39 +294,267 @@ function pauseUnlessCancelled(ms, cancel) {
             done();
     });
 }
+function findingIds(findings) {
+    const seen = new Map();
+    return findings.map((finding) => {
+        const key = opensFindingKey(finding);
+        const n = seen.get(key) ?? 0;
+        seen.set(key, n + 1);
+        return `${key}#${n}`;
+    });
+}
+function countByKey(findings) {
+    const out = new Map();
+    for (const finding of findings)
+        out.set(opensFindingKey(finding), (out.get(opensFindingKey(finding)) ?? 0) + 1);
+    return out;
+}
+function ladderable(path) {
+    return /\.(jsx?|mjs)$/.test(path);
+}
+export function repairIntactness(baseline, after, exempt = new Set()) {
+    for (const [path, was] of baseline.files) {
+        const now = after.get(path);
+        if (now === undefined || now === was || isSourcePath(path) === false)
+            continue;
+        const defect = intactnessDefect(was, now, exempt, baseline.lines);
+        if (defect !== undefined) {
+            return { path: path.replace(/^\/+/, ""), defect, ratio: now.split("\n").length / Math.max(1, was.split("\n").length) };
+        }
+    }
+    return undefined;
+}
+export function intactnessReask(defect) {
+    switch (defect) {
+        case "shrank":
+            return "the reply: it left part of the app out — write the whole file, every line that already worked";
+        case "grew":
+            return "the reply: it rewrote far more than the fix needed — change only what the findings require";
+        case "names":
+            return "the reply: it dropped functions, components or variables the app still uses — keep every one that already worked";
+        case "loop":
+            return "the reply: it repeats the same lines over and over — write each line once";
+    }
+}
+function isSourcePath(path) {
+    return /\.(jsx?|tsx?|mjs)$/.test(path);
+}
+async function ladderRound(args) {
+    const t0 = args.now();
+    const ids = findingIds(args.findings);
+    const items = [];
+    for (let i = 0; i < args.findings.length; i++) {
+        const finding = args.findings[i];
+        const src = args.current.get(finding.file);
+        if (src === undefined || ladderable(finding.file) === false)
+            continue;
+        const program = parseModule(src);
+        if (program === undefined)
+            continue;
+        const ladder = gapLadder(src, program, finding);
+        const rung = args.rungs.get(ids[i]) ?? 0;
+        const gap = ladder[rung];
+        if (gap !== undefined)
+            items.push({ id: ids[i], finding, gap });
+    }
+    const groups = [...new Set(items.map((item) => item.finding.file))].flatMap((file) => {
+        const src = args.current.get(file) ?? "";
+        const inFile = items.filter((item) => item.finding.file === file);
+        return mergeGaps(src, inFile.map((item) => item.gap)).map((merged) => ({ file, src, gap: merged.gap, members: merged.members.map((i) => inFile[i]) }));
+    });
+    if (groups.length === 0) {
+        return { round: { kind: "ladder", ms: 0, gaps: [] }, usage: [], touched: [], noGaps: true, throttled: false, cancelled: false };
+    }
+    const usage = [];
+    const fills = await Promise.all(groups.map(async (group) => {
+        const messages = regionMessages({
+            system: args.system,
+            path: group.file,
+            src: group.src,
+            gap: group.gap,
+            findings: group.members.map((member) => member.finding),
+            userFirst: args.model.name === "haiku",
+        });
+        const answer = await callWithin(args.call, { model: args.model, messages, timeoutMs: args.timeoutMs }, args.cancel);
+        if (answer.kind === "cancelled")
+            return { result: "rejected:cancelled", climbs: false };
+        if (answer.kind === "deadline")
+            return { result: "rejected:deadline", climbs: false };
+        if (answer.reply.isErr()) {
+            return isThrottle(answer.reply.Err())
+                ? { result: "rejected:throttled", climbs: false }
+                : { result: "rejected:error", climbs: false };
+        }
+        const reply = answer.reply.Ok();
+        if (reply.usage !== undefined)
+            usage.push(reply.usage);
+        const raw = regionFill(reply.text, group.src.slice(group.gap.start, group.gap.end));
+        if (raw === undefined)
+            return { result: "rejected:no-fill", climbs: true };
+        const fill = group.gap.node === "Identifier" ? identFill(group.src, group.gap, raw) : raw;
+        const defect = fillDefect(group.src, group.gap, fill);
+        if (defect !== undefined)
+            return { result: `rejected:${defect}`, climbs: true };
+        return { fill: group.gap.node === "Identifier" ? fill.trim() : fill, result: "accepted", climbs: false };
+    }));
+    const before = countByKey(args.findings);
+    const kept = [];
+    let gated;
+    let overridable;
+    const results = fills.map((f) => f.result);
+    for (let i = 0; i < groups.length; i++) {
+        const fill = fills[i].fill;
+        if (fill === undefined)
+            continue;
+        const trial = [...kept, { group: groups[i], fill }];
+        const vfs = new Map(args.current);
+        for (const file of new Set(trial.map((t) => t.group.file))) {
+            const inFile = trial.filter((t) => t.group.file === file);
+            vfs.set(file, splice(args.current.get(file) ?? "", inFile.map((t) => t.group.gap), inFile.map((t) => t.fill)));
+        }
+        const touched = [...new Set(trial.map((t) => t.group.file))];
+        const checked = autofixAndCheck({ vfs, changed: [...args.changed, ...touched], look: args.look, baseline: args.baseline });
+        const after = countByKey(checked.blocking);
+        const added = checked.unlocated > 0 || [...after].some(([key, n]) => n > (before.get(key) ?? 0));
+        const served = countByKey(groups[i].members.map((member) => member.finding));
+        const gone = [...served].every(([key, n]) => (after.get(key) ?? 0) <= (before.get(key) ?? 0) - n);
+        const gutted = repairIntactness(args.preRepair, checked.vfs, args.exempt);
+        if (added)
+            results[i] = "rejected:regress";
+        else if (gone === false)
+            results[i] = "rejected:still";
+        else if (gutted !== undefined) {
+            results[i] = `rejected:gutted:${gutted.defect}`;
+            if (checked.opens && (overridable === undefined || Math.abs(1 - gutted.ratio) < Math.abs(1 - overridable.ratio))) {
+                overridable = { gated: checked, ratio: gutted.ratio, touched };
+            }
+        }
+        else {
+            kept.push({ group: groups[i], fill });
+            gated = checked;
+        }
+    }
+    for (let i = 0; i < groups.length; i++) {
+        const refused = results[i] !== "accepted" && (fills[i].climbs || fills[i].fill !== undefined);
+        if (refused === false)
+            continue;
+        for (const member of groups[i].members)
+            args.rungs.set(member.id, (args.rungs.get(member.id) ?? 0) + 1);
+    }
+    return {
+        round: {
+            kind: "ladder",
+            ms: args.now() - t0,
+            gaps: groups.slice(0, 8).map((group, i) => ({
+                rung: group.gap.level,
+                lines: group.gap.endLine - group.gap.startLine + 1,
+                result: results[i],
+            })),
+        },
+        usage,
+        ...(gated === undefined ? {} : { gated }),
+        ...(overridable === undefined ? {} : { overridable }),
+        touched: [...new Set(kept.map((k) => k.group.file))],
+        noGaps: false,
+        throttled: results.length > 0 && results.every((r) => r === "rejected:throttled") && usage.length === 0,
+        cancelled: results.some((r) => r === "rejected:cancelled"),
+    };
+}
 export async function runInstantCandidate(args) {
+    const baseline = args.baseline ?? opensBaseline(args.base);
     const now = args.now ?? Date.now;
-    const maxAttempts = args.maxAttempts ?? INSTANT_MAX_ATTEMPTS;
+    const random = args.random ?? Math.random;
+    const repairMode = args.repairMode ?? INSTANT_REPAIR_MODE;
+    let route = repairMode === "router" ? undefined : repairMode;
+    const ladderBudget = () => (route === "ladder" ? (args.ladderRounds ?? INSTANT_LADDER_ROUNDS) : 0);
+    const modeLabel = () => (repairMode === "router" ? `router:${route ?? "none"}` : repairMode);
     const { model } = args.spec;
+    const maxAttempts = args.maxAttempts ?? model.maxAttempts;
+    const system = args.spec.messages.filter((message) => message.role === "system");
     const usage = [];
+    const repairs = [];
     const messages = [...args.spec.messages];
+    const rungs = new Map();
     let attempts = 0;
+    let throttled = 0;
+    let throttledRounds = 0;
+    let repairsDropped = 0;
     let providerErrors = 0;
+    let ladderRun = 0;
     let firstFindings = [];
+    let liveFindings = [];
     let lastError = "no attempt";
     let current = args.base;
     let changed = new Set();
+    let repairing = false;
+    const editBase = sourceFiles(args.base);
+    let preRepair = editBase.size > 0 ? { files: editBase, lines: "shrink" } : undefined;
+    const repairNames = new Set();
+    let overridable;
+    let reemitStartedAt;
+    function record(row) {
+        if (repairs.length < INSTANT_REPAIR_ROWS_MAX)
+            repairs.push(row);
+        else
+            repairsDropped++;
+    }
     function end(gate, extra) {
         return {
             name: model.name,
+            candidate: args.spec.label ?? model.name,
             model: model.id,
             gate,
             attempts,
+            throttled,
             ms: now() - args.startedAt,
             usage,
             abortedInFlight: false,
             findings: firstFindings,
+            repairs,
+            ...(repairsDropped > 0 ? { repairsDropped } : {}),
             ...extra,
         };
     }
+    function noteOverridable(candidate) {
+        if (overridable === undefined || Math.abs(1 - candidate.ratio) < Math.abs(1 - overridable.ratio))
+            overridable = candidate;
+    }
+    function exhausted(error) {
+        if (overridable === undefined)
+            return end("fail", { error });
+        record({ kind: overridable.kind, mode: modeLabel(), ms: 0, result: "accepted:gate-overridden" });
+        return end("pass", { vfs: overridable.gated.vfs, changed: [...new Set([...changed, ...overridable.touched])] });
+    }
+    function waitWithin(ms) {
+        return pauseUnlessCancelled(Math.max(0, Math.min(ms, args.deadlineAt - now())), args.cancel);
+    }
+    const paidLeft = () => maxAttempts - (attempts - throttled);
+    function queueReemit(findings, lastReply) {
+        const shown = lastReply ??
+            renderRepairFiles({
+                vfs: new Map([...changed].flatMap((path) => {
+                    const content = current.get(path);
+                    return content === undefined ? [] : [[path, content]];
+                })),
+                intro: "Here is the app.",
+            });
+        messages.push({ role: "assistant", content: [{ type: "text", text: shown }] });
+        messages.push({ role: "user", content: [{ type: "text", text: composeRepairAsk(findings) }] });
+        reemitStartedAt = now();
+    }
     for (;;) {
         if (args.cancel.aborted)
             return end("cancelled", {});
         const left = args.deadlineAt - now();
         if (left <= 0)
-            return end("fail", { error: `stage budget spent after ${attempts} call(s): ${lastError}` });
-        if (attempts >= maxAttempts)
-            return end("fail", { error: `${attempts} calls without a passing answer: ${lastError}` });
+            return exhausted(`stage budget spent after ${attempts} call(s): ${lastError}`);
+        if (paidLeft() <= 0)
+            return exhausted(`${attempts} calls without a passing answer: ${lastError}`);
+        const hold = args.throttle === undefined ? 0 : Math.min(args.throttle.holdUntil - now(), left);
+        if (hold > 0) {
+            await pauseUnlessCancelled(hold, args.cancel);
+            continue;
+        }
         attempts++;
         const answer = await callWithin(args.call, { model, messages, timeoutMs: Math.min(model.callMs, left) }, args.cancel);
         if (answer.kind === "cancelled")
@@ -299,34 +566,138 @@ export async function runInstantCandidate(args) {
         if (answer.reply.isErr()) {
             lastError = answer.reply.Err().message;
             providerErrors++;
-            await pauseUnlessCancelled(Math.min(8_000, 1_000 * 2 ** (providerErrors - 1)), args.cancel);
+            if (isThrottle(answer.reply.Err())) {
+                throttled++;
+                const wait = throttleWaitMs(providerErrors, random);
+                if (args.throttle === undefined)
+                    await waitWithin(wait);
+                else
+                    args.throttle.holdUntil = Math.max(args.throttle.holdUntil, now() + wait);
+                continue;
+            }
+            await waitWithin(Math.min(8_000, 1_000 * 2 ** (providerErrors - 1)));
             continue;
         }
         providerErrors = 0;
         const reply = answer.reply.Ok();
         if (reply.usage !== undefined)
             usage.push(reply.usage);
+        const reemitMs = reemitStartedAt === undefined ? undefined : now() - reemitStartedAt;
+        reemitStartedAt = undefined;
         const parsed = await parseCandidateText(reply.text, current);
         if (parsed.isErr()) {
             lastError = parsed.Err().message;
+            repairing = true;
+            preRepair ??= { files: current, lines: "none" };
+            if (reemitMs !== undefined)
+                record({ kind: "reemit", mode: modeLabel(), ms: reemitMs, result: "rejected:no-file" });
             messages.push({ role: "assistant", content: [{ type: "text", text: reply.text }] });
             messages.push({ role: "user", content: [{ type: "text", text: composeRepairAsk([`the reply: ${lastError}`]) }] });
             continue;
         }
-        changed = new Set([...changed, ...parsed.Ok().changed]);
-        const checked = autofixAndCheck({ vfs: parsed.Ok().vfs, changed: [...changed], look: args.look });
+        const nextChanged = new Set([...changed, ...parsed.Ok().changed]);
+        const checked = autofixAndCheck({ vfs: parsed.Ok().vfs, changed: [...nextChanged], look: args.look, baseline });
         const gated = parsed.Ok().applyErrors.length === 0
             ? checked
             : { ...checked, opens: false, findings: [...parsed.Ok().applyErrors, ...checked.findings] };
+        const applyErrors = parsed.Ok().applyErrors.length;
         if (gated.opens) {
-            return end("pass", { vfs: gated.vfs, changed: [...changed] });
+            const gutted = repairing && preRepair !== undefined ? repairIntactness(preRepair, gated.vfs, repairNames) : undefined;
+            if (gutted === undefined) {
+                if (reemitMs !== undefined)
+                    record({ kind: "reemit", mode: modeLabel(), ms: reemitMs, result: "accepted" });
+                return end("pass", { vfs: gated.vfs, changed: [...nextChanged] });
+            }
+            record({ kind: "reemit", mode: modeLabel(), ms: reemitMs ?? 0, result: `rejected:gutted:${gutted.defect}` });
+            noteOverridable({ gated, ratio: gutted.ratio, touched: [...nextChanged], kind: "reemit" });
+            lastError = `the repair failed the intactness gate (${gutted.path}: ${gutted.defect})`;
+            queueReemit([...liveFindings, intactnessReask(gutted.defect)], reply.text);
+            continue;
+        }
+        if (reemitMs !== undefined) {
+            record({ kind: "reemit", mode: modeLabel(), ms: reemitMs, result: "rejected:still" });
+            rungs.clear();
         }
+        preRepair ??= { files: gated.vfs, lines: gated.unlocated === 0 && applyErrors === 0 ? "both" : "none" };
+        repairing = true;
+        changed = nextChanged;
         if (firstFindings.length === 0)
             firstFindings = gated.findings.slice(0, 6);
         lastError = gated.findings.slice(0, 3).join("; ");
+        liveFindings = gated.findings;
+        for (const finding of gated.blocking)
+            if (finding.name !== undefined)
+                repairNames.add(finding.name);
         current = gated.vfs;
-        messages.push({ role: "assistant", content: [{ type: "text", text: reply.text }] });
-        messages.push({ role: "user", content: [{ type: "text", text: composeRepairAsk(gated.findings) }] });
+        route ??=
+            gated.blocking.some((finding) => INSTANT_REEMIT_CLASSES.has(finding.class)) ||
+                gated.unlocated > 0 ||
+                parsed.Ok().applyErrors.length > 0
+                ? "reemit"
+                : "ladder";
+        let state = gated;
+        while (ladderRun < ladderBudget() &&
+            paidLeft() > 1 &&
+            throttledRounds < INSTANT_THROTTLED_ROUNDS_MAX &&
+            applyErrors === 0 &&
+            state.unlocated === 0) {
+            if (args.cancel.aborted)
+                return end("cancelled", {});
+            const roundLeft = args.deadlineAt - now();
+            if (roundLeft <= 0)
+                return exhausted(`stage budget spent after ${attempts} call(s): ${lastError}`);
+            const round = await ladderRound({
+                call: args.call,
+                model,
+                system,
+                cancel: args.cancel,
+                timeoutMs: Math.min(model.callMs, roundLeft),
+                current,
+                findings: state.blocking,
+                rungs,
+                changed,
+                look: args.look,
+                baseline,
+                preRepair: preRepair ?? { files: current, lines: "none" },
+                exempt: repairNames,
+                ...(args.throttle === undefined ? {} : { throttle: args.throttle }),
+                now,
+            });
+            if (round.noGaps)
+                break;
+            attempts++;
+            ladderRun++;
+            usage.push(...round.usage);
+            record({ ...round.round, mode: modeLabel() });
+            if (round.cancelled && args.cancel.aborted)
+                return end("cancelled", { abortedInFlight: true });
+            if (round.overridable !== undefined)
+                noteOverridable({ ...round.overridable, kind: "ladder" });
+            if (round.throttled) {
+                throttled++;
+                ladderRun--;
+                throttledRounds++;
+                const wait = throttleWaitMs(++providerErrors, random);
+                if (args.throttle !== undefined)
+                    args.throttle.holdUntil = Math.max(args.throttle.holdUntil, now() + wait);
+                await waitWithin((args.throttle?.holdUntil ?? now() + wait) - now());
+                continue;
+            }
+            providerErrors = 0;
+            if (round.gated === undefined)
+                continue;
+            changed = new Set([...changed, ...round.touched]);
+            current = round.gated.vfs;
+            state = round.gated;
+            if (state.opens)
+                return end("pass", { vfs: state.vfs, changed: [...changed] });
+            lastError = state.findings.slice(0, 3).join("; ");
+            liveFindings = state.findings;
+            for (const finding of state.blocking)
+                if (finding.name !== undefined)
+                    repairNames.add(finding.name);
+        }
+        queueReemit(state.findings, state === gated ? reply.text : undefined);
     }
 }
 export async function raceInstantCandidates(args) {
@@ -358,20 +729,24 @@ export async function raceInstantCandidates(args) {
 export function instantReceipt(race) {
     return {
         candidates: race.outcomes.map((outcome) => ({
+            candidate: outcome.candidate,
             model: outcome.model,
             ms: outcome.ms,
             gate: outcome.gate,
             attempts: outcome.attempts,
+            ...(outcome.throttled > 0 ? { throttled: outcome.throttled } : {}),
+            ...(outcome.repairs.length > 0 ? { repairs: outcome.repairs } : {}),
+            ...(outcome.repairsDropped === undefined ? {} : { repairsDropped: outcome.repairsDropped }),
             ...(outcome.abortedInFlight ? { abortedInFlight: true } : {}),
         })),
-        ...(race.winner === undefined ? {} : { winner: race.winner.model }),
+        ...(race.winner === undefined ? {} : { winner: race.winner.model, winnerCandidate: race.winner.candidate }),
     };
 }
 export function instantTurnText(race) {
     const winner = race.winner;
     if (winner === undefined || winner.vfs === undefined || winner.changed === undefined) {
         const why = race.outcomes
-            .map((outcome) => `${outcome.name}: ${outcome.error ?? outcome.findings.slice(0, 2).join("; ")}`)
+            .map((outcome) => `${outcome.candidate}: ${outcome.error ?? outcome.findings.slice(0, 2).join("; ")}`)
             .join("\n");
         return `The instant build wrote no files that open, so nothing was saved.\n\n${why}\n`;
     }
@@ -415,29 +790,72 @@ export function mercuryMessages(args) {
         { role: "user", content: [{ type: "text", text: ask }] },
     ];
 }
-export async function runInstantBuild(args) {
-    const { assembly } = args;
-    const specs = [
-        ...(assembly.mercurySystem === undefined
-            ? []
-            : [
-                {
-                    model: instantModelChoice("mercury"),
-                    messages: mercuryMessages({ system: assembly.mercurySystem, instruction: assembly.instruction, base: assembly.base }),
-                },
-            ]),
-        { model: instantModelChoice("haiku"), messages: args.haikuMessages },
-    ];
-    const race = await raceInstantCandidates({
-        specs,
-        budgetMs: args.budgetMs ?? INSTANT_STAGE_BUDGET_MS,
-        turn: args.turn,
-        run: ({ spec, cancel, startedAt, deadlineAt }) => runInstantCandidate({ call: args.call, spec, base: assembly.base, look: assembly.look, cancel, startedAt, deadlineAt }),
-    });
+function crashedCandidate(spec, startedAt, e) {
     return {
-        response: instantResponse({ race, promptId: args.promptId }),
-        receipt: instantReceipt(race),
-        model: race.winner?.model ?? INSTANT_HAIKU_MODEL,
+        name: spec.model.name,
+        candidate: spec.label ?? spec.model.name,
+        model: spec.model.id,
+        gate: "fail",
+        attempts: 0,
+        throttled: 0,
+        ms: Date.now() - startedAt,
+        usage: [],
+        abortedInFlight: false,
+        findings: [],
+        repairs: [],
+        error: `candidate crashed: ${e instanceof Error ? e.message : String(e)}`,
     };
 }
+export function instantSpecs(args) {
+    const { assembly } = args;
+    const system = assembly.mercurySystem;
+    const mercury = system === undefined
+        ? []
+        : Array.from({ length: Math.max(0, args.fanout) }, (_, i) => ({
+            model: instantModelChoice("mercury"),
+            label: `mercury-${i + 1}`,
+            messages: mercuryMessages({ system, instruction: assembly.instruction, base: assembly.base }),
+        }));
+    return [...mercury, { model: instantModelChoice("haiku"), label: "haiku", messages: args.haikuMessages }];
+}
+export async function runInstantBuild(args) {
+    const { assembly } = args;
+    const breaker = args.breaker ?? INSTANT_MERCURY_BREAKER;
+    const admission = assembly.mercurySystem === undefined ? undefined : breaker.admit();
+    const fanout = admission === undefined || admission === "closed" ? (args.mercuryFanout ?? INSTANT_MERCURY_FANOUT) : 1;
+    const specs = instantSpecs({ assembly, haikuMessages: args.haikuMessages, fanout });
+    const mercuryThrottle = { holdUntil: 0 };
+    const baseline = opensBaseline(sourceFiles(assembly.base));
+    let race;
+    try {
+        race = await raceInstantCandidates({
+            specs,
+            budgetMs: args.budgetMs ?? INSTANT_STAGE_BUDGET_MS,
+            turn: args.turn,
+            run: ({ spec, cancel, startedAt, deadlineAt }) => runInstantCandidate({
+                call: args.call,
+                spec,
+                base: assembly.base,
+                look: assembly.look,
+                cancel,
+                startedAt,
+                deadlineAt,
+                baseline,
+                ...(spec.model.name === "mercury" ? { throttle: mercuryThrottle } : {}),
+            }).catch((e) => crashedCandidate(spec, startedAt, e)),
+        });
+        return {
+            response: instantResponse({ race, promptId: args.promptId }),
+            receipt: instantReceipt(race),
+            model: race.winner?.model ?? INSTANT_HAIKU_MODEL,
+        };
+    }
+    finally {
+        if (admission !== undefined && admission !== "open") {
+            const mercury = race?.outcomes.filter((outcome) => outcome.name === "mercury") ?? [];
+            const trouble = mercury.some((o) => o.throttled > 0) && mercury.every((o) => o.usage.length === 0);
+            breaker.record(admission, race === undefined ? { ok: false, cause: "error" } : trouble ? { ok: false, cause: "rate-limited" } : { ok: true });
+        }
+    }
+}
 //# sourceMappingURL=instant-build.js.map