@vibes.diy/api-svc 14.3.94 → 14.3.96

package/intern/instant-build.d.ts

@@ -1,5 +1,6 @@
 import { Result } from "@adviser/cement";
 import { type LLMMessage, type SseUsage } from "@vibes.diy/call-ai-v2";
+import { type InstantRepairModelName } from "@vibes.diy/api-types";
 import type { VibesApiSQLCtx } from "../types.js";
 import { type SynthLook } from "./import-synth.js";
 import { type OpensFinding } from "./opens-check.js";
@@ -7,7 +8,7 @@ import { type IntactnessDefect, type LineBounds } from "./repair-ladder.js";
 import { MercuryCircuitBreaker } from "./mercury-resilience.js";
 export type InstantCandidateName = "mercury" | "haiku";
 export declare const INSTANT_MERCURY_FANOUT = 4;
-export type InstantRepairMode = "router" | "ladder" | "reemit";
+export type InstantRepairMode = "sr" | "router" | "ladder" | "reemit";
 export declare const INSTANT_REPAIR_MODE: InstantRepairMode;
 export declare const INSTANT_LADDER_ROUNDS = 4;
 export declare const INSTANT_THROTTLED_ROUNDS_MAX = 6;
@@ -23,8 +24,8 @@ export declare const INSTANT_HAIKU_CALL_MS = 90000;
 export declare const INSTANT_STAGE_BUDGET_MS = 150000;
 export declare const INSTANT_MAX_ATTEMPTS = 5;
 export declare const INSTANT_MERCURY_BREAKER: MercuryCircuitBreaker;
-export interface InstantModelChoice {
-    readonly name: InstantCandidateName;
+export interface InstantCallModel {
+    readonly name: string;
     readonly id: string;
     readonly reasoning: {
         readonly effort: "none";
@@ -33,8 +34,18 @@ export interface InstantModelChoice {
     };
     readonly reasoningEffort?: string;
     readonly callMs: number;
+    readonly maxTokens?: number;
+}
+export interface InstantModelChoice extends InstantCallModel {
+    readonly name: InstantCandidateName;
     readonly maxAttempts: number;
 }
+export interface InstantRepairModel extends InstantCallModel {
+    readonly choice: InstantRepairModelName;
+    readonly cacheSystem: boolean;
+}
+export declare const INSTANT_REPAIR_MODELS: Readonly<Record<InstantRepairModelName, InstantRepairModel>>;
+export declare function instantRepairModel(setting: unknown): InstantRepairModel;
 export declare function instantModelChoice(name: InstantCandidateName): InstantModelChoice;
 export declare const INSTANT_PARAGRAPH: string;
 export declare function composeInstantBrief(sentence: string): string;
@@ -70,7 +81,7 @@ export declare function autofixAndCheck(args: {
     readonly baseline?: ReadonlySet<string>;
 }): InstantGateResult;
 export interface InstantModelRequest {
-    readonly model: InstantModelChoice;
+    readonly model: InstantCallModel;
     readonly messages: readonly LLMMessage[];
     readonly signal: AbortSignal;
 }
@@ -83,6 +94,10 @@ export interface InstantModelReply {
     readonly usage?: InstantRoundUsage;
 }
 export type InstantModelCall = (req: InstantModelRequest) => Promise<Result<InstantModelReply>>;
+export declare class InstantPaidReplyError extends Error {
+    readonly usage: InstantRoundUsage | undefined;
+    constructor(message: string, usage: InstantRoundUsage | undefined);
+}
 export declare function instantModelCallFor(vctx: Pick<VibesApiSQLCtx, "llmRequest" | "params">): InstantModelCall;
 export interface InstantCandidateSpec {
     readonly model: InstantModelChoice;
@@ -109,6 +124,7 @@ export interface InstantCandidateOutcome {
     readonly error?: string;
     readonly repairs: readonly InstantRepairRound[];
     readonly repairsDropped?: number;
+    readonly repairModel?: string;
 }
 export interface InstantRepairGap {
     readonly rung: string;
@@ -116,9 +132,10 @@ export interface InstantRepairGap {
     readonly result: string;
 }
 export interface InstantRepairRound {
-    readonly kind: "ladder" | "reemit";
+    readonly kind: "ladder" | "reemit" | "sr";
     readonly mode: string;
     readonly ms: number;
+    readonly model?: string;
     readonly result?: string;
     readonly gaps?: readonly InstantRepairGap[];
 }
@@ -133,6 +150,22 @@ export interface IntactRefusal {
 }
 export declare function repairIntactness(baseline: IntactBaseline, after: ReadonlyMap<string, string>, exempt?: ReadonlySet<string>): IntactRefusal | undefined;
 export declare function intactnessReask(defect: IntactnessDefect): string;
+export declare const SR_NOTE_NO_MATCH = "Your last SEARCH blocks did not match the file; copy the SEARCH lines exactly from the file above.";
+export declare const SR_NOTE_NO_EDITS = "Your last reply had no SEARCH/REPLACE blocks.";
+export declare const SR_NOTE_NO_CHANGE = "Your last edits left the file exactly as it was; change the lines the findings name.";
+export declare function srIntactnessNote(defect: IntactnessDefect): string;
+export declare function composeSrRepairAsk(args: {
+    readonly findings: readonly string[];
+    readonly paths: readonly string[];
+    readonly note?: string;
+}): string;
+export declare function srRepairMessages(args: {
+    readonly system: readonly LLMMessage[];
+    readonly files: ReadonlyMap<string, string>;
+    readonly findings: readonly string[];
+    readonly note?: string;
+    readonly model: InstantRepairModel;
+}): LLMMessage[];
 export declare function runInstantCandidate(args: {
     readonly call: InstantModelCall;
     readonly spec: InstantCandidateSpec;
@@ -148,6 +181,7 @@ export declare function runInstantCandidate(args: {
     readonly baseline?: ReadonlySet<string>;
     readonly repairMode?: InstantRepairMode;
     readonly ladderRounds?: number;
+    readonly repairModel?: InstantRepairModel;
 }): Promise<InstantCandidateOutcome>;
 export interface InstantRaceResult {
     readonly winner?: InstantCandidateOutcome;
@@ -177,6 +211,7 @@ export interface InstantReceipt {
         readonly abortedInFlight?: true;
         readonly repairs?: readonly InstantRepairRound[];
         readonly repairsDropped?: number;
+        readonly repairModel?: string;
     }[];
     readonly winner?: string;
     readonly winnerCandidate?: string;
@@ -192,6 +227,7 @@ export interface InstantAssembly {
     readonly instruction: string;
     readonly look: SynthLook;
     readonly base: ReadonlyMap<string, string>;
+    readonly repairModel?: InstantRepairModelName;
 }
 export interface InstantBuildOutcome {
     readonly response: Response;

package/intern/instant-build.js

@@ -3,17 +3,18 @@ import { type } from "arktype";
 import { makeBaseSystemPrompt } from "@vibes.diy/prompts";
 import { createBlockStream, isCodeEnd, } from "@vibes.diy/call-ai-v2";
 import { lazyType } from "@vibes.diy/api-types/lazy-type";
+import { instantRepairModelName } from "@vibes.diy/api-types";
 import { createBlockAccumulator, createStreamingResolver, resolveCodeBlocks } from "./prompt-streaming.js";
 import { synthesizeImports } from "./import-synth.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 { composeRepairAsk, fenceLang, 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_REPAIR_MODE = "sr";
 export const INSTANT_LADDER_ROUNDS = 4;
 export const INSTANT_THROTTLED_ROUNDS_MAX = 6;
 export const INSTANT_REPAIR_ROWS_MAX = 24;
@@ -30,6 +31,30 @@ 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 const INSTANT_REPAIR_MODELS = {
+    deepseek: {
+        choice: "deepseek",
+        name: "repair:deepseek",
+        id: "deepseek/deepseek-v4.1-flash:nitro",
+        reasoning: { enabled: false },
+        cacheSystem: false,
+        callMs: 30_000,
+        maxTokens: 16_000,
+    },
+    haiku: {
+        choice: "haiku",
+        name: "repair:haiku",
+        id: "anthropic/claude-haiku-5.5:nitro",
+        reasoning: { effort: "none" },
+        reasoningEffort: "none",
+        cacheSystem: true,
+        callMs: 30_000,
+        maxTokens: 16_000,
+    },
+};
+export function instantRepairModel(setting) {
+    return INSTANT_REPAIR_MODELS[instantRepairModelName(setting)];
+}
 export function instantModelChoice(name) {
     switch (name) {
         case "mercury":
@@ -187,6 +212,20 @@ export function autofixAndCheck(args) {
         notes: fixed.notes,
     };
 }
+export class InstantPaidReplyError extends Error {
+    usage;
+    constructor(message, usage) {
+        super(message);
+        this.usage = usage;
+        this.name = "InstantPaidReplyError";
+    }
+}
+function settledUsage(reply) {
+    if (reply.isOk())
+        return reply.Ok().usage;
+    const error = reply.Err();
+    return error instanceof InstantPaidReplyError ? error.usage : undefined;
+}
 const completionBody = lazyType(() => type({
     "model?": "string",
     choices: type({ message: { content: "string | null" }, "finish_reason?": "string | null" }).array(),
@@ -202,7 +241,7 @@ export function instantModelCallFor(vctx) {
         const body = {
             model: req.model.id,
             stream: false,
-            max_tokens: INSTANT_MAX_OUTPUT_TOKENS,
+            max_tokens: req.model.maxTokens ?? INSTANT_MAX_OUTPUT_TOKENS,
             reasoning: { ...req.model.reasoning },
             messages: [...req.messages],
         };
@@ -220,28 +259,23 @@ export function instantModelCallFor(vctx) {
         const parsed = completionBody(rJson.Ok());
         if (parsed instanceof type.errors)
             return Result.Err(`instant ${req.model.name}: reply: ${parsed.summary}`);
+        const u = parsed.usage;
+        const servedModel = parsed.model ?? req.model.id;
+        const usage = u === undefined
+            ? undefined
+            : {
+                prompt_tokens: u.prompt_tokens ?? 0,
+                completion_tokens: u.completion_tokens ?? 0,
+                total_tokens: u.total_tokens ?? (u.prompt_tokens ?? 0) + (u.completion_tokens ?? 0),
+                model: servedModel,
+                ...(req.model.reasoningEffort === undefined ? {} : { reasoningEffort: req.model.reasoningEffort }),
+                ...(u.cost === undefined ? {} : { cost: u.cost }),
+            };
         const content = parsed.choices[0]?.message.content;
         if (content === undefined || content === null || content.trim().length === 0) {
-            return Result.Err(`instant ${req.model.name}: empty reply (finish ${parsed.choices[0]?.finish_reason ?? "unknown"})`);
+            return Result.Err(new InstantPaidReplyError(`instant ${req.model.name}: empty reply (finish ${parsed.choices[0]?.finish_reason ?? "unknown"})`, usage));
         }
-        const u = parsed.usage;
-        const servedModel = parsed.model ?? req.model.id;
-        return Result.Ok({
-            text: content,
-            servedModel,
-            ...(u === undefined
-                ? {}
-                : {
-                    usage: {
-                        prompt_tokens: u.prompt_tokens ?? 0,
-                        completion_tokens: u.completion_tokens ?? 0,
-                        total_tokens: u.total_tokens ?? (u.prompt_tokens ?? 0) + (u.completion_tokens ?? 0),
-                        model: servedModel,
-                        ...(req.model.reasoningEffort === undefined ? {} : { reasoningEffort: req.model.reasoningEffort }),
-                        ...(u.cost === undefined ? {} : { cost: u.cost }),
-                    },
-                }),
-        });
+        return Result.Ok({ text: content, servedModel, ...(usage === undefined ? {} : { usage }) });
     };
 }
 function isThrottle(error) {
@@ -275,11 +309,13 @@ async function callWithin(call, req, cancel) {
         clearTimeout(timer);
         cancel.removeEventListener("abort", cancelled);
     });
+    const usage = settledUsage(reply);
+    const paid = usage === undefined ? {} : { usage };
     if (cancel.aborted)
-        return { kind: "cancelled" };
+        return { kind: "cancelled", ...paid };
     if (abort.signal.aborted)
-        return { kind: "deadline" };
-    return { kind: "reply", reply };
+        return { kind: "deadline", ...paid };
+    return { kind: "reply", reply, ...paid };
 }
 function pauseUnlessCancelled(ms, cancel) {
     return new Promise((resolve) => {
@@ -339,6 +375,63 @@ export function intactnessReask(defect) {
 function isSourcePath(path) {
     return /\.(jsx?|tsx?|mjs)$/.test(path);
 }
+export const SR_NOTE_NO_MATCH = "Your last SEARCH blocks did not match the file; copy the SEARCH lines exactly from the file above.";
+export const SR_NOTE_NO_EDITS = "Your last reply had no SEARCH/REPLACE blocks.";
+export const SR_NOTE_NO_CHANGE = "Your last edits left the file exactly as it was; change the lines the findings name.";
+export function srIntactnessNote(defect) {
+    switch (defect) {
+        case "shrank":
+            return "Your last edits left part of the app out; keep every line that already worked.";
+        case "grew":
+            return "Your last edits rewrote far more than the fix needed; change only what the findings require.";
+        case "names":
+            return "Your last edits dropped functions, components or variables the app still uses; keep every one that already worked.";
+        case "loop":
+            return "Your last edits repeat the same lines over and over; write each line once.";
+    }
+}
+export function composeSrRepairAsk(args) {
+    const names = args.paths.map((path) => path.replace(/^\/+/, ""));
+    const first = names[0] ?? "App.jsx";
+    const target = names.length > 1 ? `the files above (${names.join(", ")})` : first;
+    return (`Opening the app in the browser reported:\n\n${args.findings.slice(0, 6).join("\n")}\n\n` +
+        (args.note === undefined ? "" : `${args.note}\n\n`) +
+        `Reply with SEARCH/REPLACE edits to ${target}, the same shape as an edit turn, and nothing else:\n\n` +
+        `### \`${first}\`\n\`\`\`${fenceLang(first)}\n<<<<<<< SEARCH\n(exact lines from the current file)\n=======\n(the replacement)\n>>>>>>> REPLACE\n\`\`\`\n\n` +
+        (names.length > 1 ? "Edit each other file the same way, under its own `### `path`` heading.\n" : "") +
+        "Each SEARCH must match the current file exactly, once. Change only what the fix needs; keep everything that already worked.");
+}
+function withoutCache(part) {
+    if (part.type === "text")
+        return { type: "text", text: part.text };
+    if (part.type === "image_url")
+        return { type: "image_url", image_url: part.image_url };
+    return part;
+}
+export function srRepairMessages(args) {
+    const system = args.system.flatMap((message) => message.role === "system" && Array.isArray(message.content)
+        ? [{ role: "system", content: message.content.map(withoutCache) }]
+        : []);
+    const last = system[system.length - 1];
+    if (args.model.cacheSystem && last !== undefined) {
+        const at = last.content.map((part) => part.type).lastIndexOf("text");
+        const part = last.content[at];
+        if (part !== undefined && part.type === "text") {
+            last.content[at] = { type: "text", text: part.text, cache_control: { type: "ephemeral" } };
+        }
+    }
+    const files = renderRepairFiles({ vfs: args.files, intro: "Here is the app." });
+    const ask = composeSrRepairAsk({
+        findings: args.findings,
+        paths: [...args.files.keys()].sort((a, b) => Number(b === "/App.jsx") - Number(a === "/App.jsx")),
+        ...(args.note === undefined ? {} : { note: args.note }),
+    });
+    return [
+        ...system,
+        { role: "assistant", content: [{ type: "text", text: files }] },
+        { role: "user", content: [{ type: "text", text: ask }] },
+    ];
+}
 async function ladderRound(args) {
     const t0 = args.now();
     const ids = findingIds(args.findings);
@@ -376,6 +469,8 @@ async function ladderRound(args) {
             userFirst: args.model.name === "haiku",
         });
         const answer = await callWithin(args.call, { model: args.model, messages, timeoutMs: args.timeoutMs }, args.cancel);
+        if (answer.usage !== undefined)
+            usage.push(answer.usage);
         if (answer.kind === "cancelled")
             return { result: "rejected:cancelled", climbs: false };
         if (answer.kind === "deadline")
@@ -386,8 +481,6 @@ async function ladderRound(args) {
                 : { 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 };
@@ -465,7 +558,9 @@ export async function runInstantCandidate(args) {
     const now = args.now ?? Date.now;
     const random = args.random ?? Math.random;
     const repairMode = args.repairMode ?? INSTANT_REPAIR_MODE;
-    let route = repairMode === "router" ? undefined : repairMode;
+    const repairModel = args.repairModel ?? instantRepairModel(undefined);
+    let repairModelCalled = false;
+    let route = repairMode === "router" ? undefined : repairMode === "sr" ? "reemit" : repairMode;
     const ladderBudget = () => (route === "ladder" ? (args.ladderRounds ?? INSTANT_LADDER_ROUNDS) : 0);
     const modeLabel = () => (repairMode === "router" ? `router:${route ?? "none"}` : repairMode);
     const { model } = args.spec;
@@ -512,6 +607,7 @@ export async function runInstantCandidate(args) {
             findings: firstFindings,
             repairs,
             ...(repairsDropped > 0 ? { repairsDropped } : {}),
+            ...(repairModelCalled ? { repairModel: repairModel.id } : {}),
             ...extra,
         };
     }
@@ -522,7 +618,13 @@ export async function runInstantCandidate(args) {
     function exhausted(error) {
         if (overridable === undefined)
             return end("fail", { error });
-        record({ kind: overridable.kind, mode: modeLabel(), ms: 0, result: "accepted:gate-overridden" });
+        record({
+            kind: overridable.kind,
+            mode: overridable.kind === "sr" ? "sr" : modeLabel(),
+            ms: 0,
+            ...(overridable.kind === "sr" ? { model: repairModel.id } : {}),
+            result: "accepted:gate-overridden",
+        });
         return end("pass", { vfs: overridable.gated.vfs, changed: [...new Set([...changed, ...overridable.touched])] });
     }
     function waitWithin(ms) {
@@ -542,6 +644,101 @@ export async function runInstantCandidate(args) {
         messages.push({ role: "user", content: [{ type: "text", text: composeRepairAsk(findings) }] });
         reemitStartedAt = now();
     }
+    async function srRepair() {
+        repairModelCalled = true;
+        let note;
+        for (;;) {
+            if (args.cancel.aborted)
+                return end("cancelled", {});
+            const left = args.deadlineAt - now();
+            if (left <= 0)
+                return exhausted(`stage budget spent after ${attempts} call(s): ${lastError}`);
+            if (paidLeft() <= 0)
+                return exhausted(`${attempts} calls without a passing answer: ${lastError}`);
+            attempts++;
+            const startedAt = now();
+            const row = (result) => record({ kind: "sr", mode: "sr", model: repairModel.id, ms: now() - startedAt, result });
+            const request = srRepairMessages({
+                system,
+                files: sourceFiles(current),
+                findings: liveFindings,
+                ...(note === undefined ? {} : { note }),
+                model: repairModel,
+            });
+            const answer = await callWithin(args.call, { model: repairModel, messages: request, timeoutMs: Math.min(repairModel.callMs, left) }, args.cancel);
+            if (answer.usage !== undefined)
+                usage.push(answer.usage);
+            if (answer.kind === "cancelled")
+                return end("cancelled", { abortedInFlight: true });
+            if (answer.kind === "deadline") {
+                lastError = `repair call ${attempts} passed its deadline`;
+                row("rejected:deadline");
+                continue;
+            }
+            if (answer.reply.isErr()) {
+                lastError = answer.reply.Err().message;
+                providerErrors++;
+                if (isThrottle(answer.reply.Err())) {
+                    throttled++;
+                    row("rejected:throttled");
+                    await waitWithin(throttleWaitMs(providerErrors, random));
+                    continue;
+                }
+                row("rejected:error");
+                await waitWithin(Math.min(8_000, 1_000 * 2 ** (providerErrors - 1)));
+                continue;
+            }
+            providerErrors = 0;
+            const reply = answer.reply.Ok();
+            const parsed = await parseCandidateText(reply.text, current);
+            if (parsed.isErr()) {
+                lastError = "the repair reply held no SEARCH/REPLACE block";
+                note = SR_NOTE_NO_EDITS;
+                row("rejected:no-edit");
+                continue;
+            }
+            const edit = parsed.Ok();
+            if (edit.changed.every((path) => edit.vfs.get(path) === current.get(path))) {
+                if (edit.applyErrors.length > 0) {
+                    lastError = edit.applyErrors.slice(0, 3).join("; ");
+                    note = SR_NOTE_NO_MATCH;
+                    row("rejected:no-match");
+                }
+                else {
+                    note = SR_NOTE_NO_CHANGE;
+                    row("rejected:no-change");
+                }
+                continue;
+            }
+            const nextChanged = new Set([...changed, ...edit.changed]);
+            const checked = autofixAndCheck({ vfs: edit.vfs, changed: [...nextChanged], look: args.look, baseline });
+            const gated = edit.applyErrors.length === 0
+                ? checked
+                : { ...checked, opens: false, findings: [...edit.applyErrors, ...checked.findings] };
+            const gutted = preRepair === undefined ? undefined : repairIntactness(preRepair, gated.vfs, repairNames);
+            if (gutted !== undefined) {
+                if (gated.opens)
+                    noteOverridable({ gated, ratio: gutted.ratio, touched: [...nextChanged], kind: "sr" });
+                lastError = `the repair failed the intactness gate (${gutted.path}: ${gutted.defect})`;
+                note = srIntactnessNote(gutted.defect);
+                row(`rejected:gutted:${gutted.defect}`);
+                continue;
+            }
+            if (gated.opens) {
+                row("accepted");
+                return end("pass", { vfs: gated.vfs, changed: [...nextChanged] });
+            }
+            row("rejected:still");
+            note = undefined;
+            changed = nextChanged;
+            current = gated.vfs;
+            liveFindings = gated.findings;
+            lastError = gated.findings.slice(0, 3).join("; ");
+            for (const finding of gated.blocking)
+                if (finding.name !== undefined)
+                    repairNames.add(finding.name);
+        }
+    }
     for (;;) {
         if (args.cancel.aborted)
             return end("cancelled", {});
@@ -557,6 +754,8 @@ export async function runInstantCandidate(args) {
         }
         attempts++;
         const answer = await callWithin(args.call, { model, messages, timeoutMs: Math.min(model.callMs, left) }, args.cancel);
+        if (answer.usage !== undefined)
+            usage.push(answer.usage);
         if (answer.kind === "cancelled")
             return end("cancelled", { abortedInFlight: true });
         if (answer.kind === "deadline") {
@@ -580,8 +779,6 @@ export async function runInstantCandidate(args) {
         }
         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);
@@ -629,6 +826,8 @@ export async function runInstantCandidate(args) {
             if (finding.name !== undefined)
                 repairNames.add(finding.name);
         current = gated.vfs;
+        if (repairMode === "sr" && applyErrors === 0)
+            return srRepair();
         route ??=
             gated.blocking.some((finding) => INSTANT_REEMIT_CLASSES.has(finding.class)) ||
                 gated.unlocated > 0 ||
@@ -737,6 +936,7 @@ export function instantReceipt(race) {
             ...(outcome.throttled > 0 ? { throttled: outcome.throttled } : {}),
             ...(outcome.repairs.length > 0 ? { repairs: outcome.repairs } : {}),
             ...(outcome.repairsDropped === undefined ? {} : { repairsDropped: outcome.repairsDropped }),
+            ...(outcome.repairModel === undefined ? {} : { repairModel: outcome.repairModel }),
             ...(outcome.abortedInFlight ? { abortedInFlight: true } : {}),
         })),
         ...(race.winner === undefined ? {} : { winner: race.winner.model, winnerCandidate: race.winner.candidate }),
@@ -826,6 +1026,7 @@ export async function runInstantBuild(args) {
     const specs = instantSpecs({ assembly, haikuMessages: args.haikuMessages, fanout });
     const mercuryThrottle = { holdUntil: 0 };
     const baseline = opensBaseline(sourceFiles(assembly.base));
+    const repairModel = instantRepairModel(assembly.repairModel);
     let race;
     try {
         race = await raceInstantCandidates({
@@ -841,6 +1042,7 @@ export async function runInstantBuild(args) {
                 startedAt,
                 deadlineAt,
                 baseline,
+                repairModel,
                 ...(spec.model.name === "mercury" ? { throttle: mercuryThrottle } : {}),
             }).catch((e) => crashedCandidate(spec, startedAt, e)),
         });