@vibes.diy/api-svc 14.3.84 → 14.3.86

package/public/agent-turn-action.js

@@ -1,17 +1,25 @@
-import { Result, exception2Result } from "@adviser/cement";
+import { Future, Result, exception2Result } from "@adviser/cement";
 import { isActiveTheme, isAgentChatAppSlug, } from "@vibes.diy/api-types";
-import { isChatMessage } from "@vibes.diy/call-ai-v2";
+import { isChatMessage, isSseEnd, isSseLine } from "@vibes.diy/call-ai-v2";
 import { classifyTurnReach } from "../intern/turn-reach.js";
 import { acquireTurnBuildLock, releaseTurnBuildLock } from "../intern/codegen-build-lock.js";
 import { refuseCrossLaneBuild } from "../intern/cross-lane-build-guard.js";
 import { userFileBlocks } from "../intern/agent-session-runtime.js";
+import { alternativeReadyNote, startAlternativeFirstBuild, watchAlternativeLanding } from "../intern/alt-first-build.js";
+import { fireAgentWakeTurn } from "../intern/agent-wake.js";
+import { promptDispatchContext } from "../intern/prompt-dispatch-context.js";
 import { isAgentSessionSuperseded } from "../intern/agent-session.js";
 import { runEditVibeTool } from "../intern/agent-build-tools.js";
 import { claimFirstTurnMint, claimMintJob, readClaimedChatApp } from "../intern/mint-job-store.js";
 import { claimAgentAppContext } from "../intern/agent-request-frame.js";
 import { inflateAgentFiles, serverFirstBuildAppContext } from "../intern/agent-assembly.js";
 import { runServerFirstBuild } from "../intern/server-first-build.js";
+import { recordMercuryRace, runMercuryFirstBuild, } from "../intern/mercury-first-build.js";
+import { MERCURY_RATE_LIMITED_STAGE_MS } from "../intern/mercury-resilience.js";
+import { runMercurySeam, withMercuryUsageRounds, withPreambleFirst, } from "../intern/mercury-first-build-seam.js";
+import { createFirstBuildRace, createPreJoinRounds, deferredStream, joinedFirstBuildReceipt, withoutPreJoinText, } from "../intern/first-build-race.js";
 import { createAgentBelt } from "../intern/agent-belt.js";
+import { createAgentClosingOptions } from "../intern/agent-closing-options.js";
 import { createAccountAgentBelt } from "../intern/agent-account-tools.js";
 import { poufLookFor } from "../intern/pouf-look-flag.js";
 import { readComposedSettingsForApp } from "./app-setting-items.js";
@@ -33,28 +41,77 @@ import { createAgentEvidenceWriter, nextAgentSessionMessages } from "../intern/a
 import { observeEvidenceLine } from "../intern/turn-latency.js";
 import { handleLlmResponse } from "./stream-assembly.js";
 import { handleFSPrompt } from "./fs-prompt.js";
-import { FIRST_BRIEF_WORD_COUNT, fastFirstTurnLevers, AGENT_FIRST_BRIEF_ENV, agentFirstBriefEnabled, firstBriefArmed, seededAddressWordsArmed, variantForTurn, } from "../intern/instruction-variant.js";
+import { FIRST_BRIEF_WORD_COUNT, fastFirstTurnLevers, AGENT_FIRST_BRIEF_ENV, agentFirstBriefEnabled, firstBriefArmed, isMercuryVariant, mercuryRecutArmed, mercuryStyleFor, mercuryJuiceFor, mercuryDepthFor, mercuryReplyFor, mercuryDuoFor, mercuryOneCallFor, mercuryDuoPoolFor, mercuryRecordsRulesFor, mercuryVariantForTurn, mercuryPlannerFor, mercuryFormatFor, MERCURY_FIRST_BUILD_ENV, seededAddressWordsArmed, variantForTurn, } from "../intern/instruction-variant.js";
+import { isEvalHandle } from "../intern/eval-handles.js";
 import { slugWordBag } from "../intern/ensure-slug-binding.js";
 import { firstBriefOutcomeFromReceipt, firstBriefTools, firstBriefTurnEligible, observeFirstBriefRound, recordFirstBriefOutcome, recordFirstBriefRow, withFirstBriefLine, withSeededAddressWordsLine, withoutFirstBriefLine, withFirstBriefContinueNote, } from "../intern/first-brief.js";
+export const FIRST_BUILD_RACE_EVIDENCE_NAME = "first-build-race";
 export function createAgentTurnAction(args) {
     const { ctx, vctx, req, orig, resChat, agentPayload, liveSession, agentEvidence, agentFetchUrlContext, firstBuildVerdict, agentFirstTurnMint, submittedAt, agentWakeTurn, dispatchCarry, instructionVariant, turnLatency, terminal, facts, reenter, } = args;
     const topLevel = isAgentChatAppSlug(resChat.appSlug);
     const turnVariant = variantForTurn(instructionVariant, { firstTurn: agentFirstTurnMint });
     const fastLevers = fastFirstTurnLevers(instructionVariant, agentFirstTurnMint);
     const personWords = currentUserMessageText(orig.prompt.messages.filter(isChatMessage));
-    const briefArmed = firstBriefArmed(instructionVariant, agentFirstTurnMint, agentFirstBriefEnabled(vctx.sthis.env.get(AGENT_FIRST_BRIEF_ENV))) &&
-        firstBriefTurnEligible({
-            wakeTurn: agentWakeTurn,
-            topLevel,
-            personWords,
-            linkedUrls: agentFetchUrlContext?.activatedUrls.length ?? 0,
-        });
+    const briefEligible = firstBriefTurnEligible({
+        wakeTurn: agentWakeTurn,
+        topLevel,
+        personWords,
+        linkedUrls: agentFetchUrlContext?.activatedUrls.length ?? 0,
+    });
+    const briefDefaultOn = agentFirstBriefEnabled(vctx.sthis.env.get(AGENT_FIRST_BRIEF_ENV));
+    const mercuryVariant = mercuryVariantForTurn({
+        instructionVariant,
+        flag: vctx.sthis.env.get(MERCURY_FIRST_BUILD_ENV),
+    });
+    const mercurySwitched = mercuryVariant !== undefined && instructionVariant === undefined;
+    const mercuryKeepText = isEvalHandle(resChat.ownerHandle);
+    const mercuryFormat = mercuryFormatFor(mercuryVariant);
+    const mercuryPlanner = mercuryPlannerFor(mercuryVariant);
+    const mercuryPlannerNamed = mercuryPlanner === "mercury" ? undefined : mercuryPlanner;
+    const mercuryArmed = mercuryRecutArmed(mercuryVariant, agentFirstTurnMint) && briefEligible;
+    const briefArmed = mercuryArmed
+        ? firstBriefArmed(undefined, agentFirstTurnMint, briefDefaultOn) && briefEligible
+        : firstBriefArmed(instructionVariant, agentFirstTurnMint, briefDefaultOn) && briefEligible;
     const seededWordsArmed = seededAddressWordsArmed(instructionVariant, agentFirstTurnMint) &&
         agentWakeTurn === false &&
         topLevel === false &&
         personWords.length > 0;
     return async ({ scope, blockSeq, promptId }) => {
-        const briefWords = briefArmed || seededWordsArmed ? slugWordBag(FIRST_BRIEF_WORD_COUNT) : [];
+        const briefWords = briefArmed || seededWordsArmed || mercuryArmed ? slugWordBag(FIRST_BRIEF_WORD_COUNT) : [];
+        const mercuryRounds = [];
+        const mercuryCancel = new AbortController();
+        const race = mercuryArmed
+            ? createFirstBuildRace({ onAgentWon: () => mercuryCancel.abort() })
+            : undefined;
+        let lastMercuryRow;
+        const mercuryPending = mercuryArmed
+            ? runMercuryFirstBuild(vctx, {
+                chatId: req.chatId,
+                signal: mercuryCancel.signal,
+                onRowWritten: (rowId) => {
+                    lastMercuryRow = rowId;
+                },
+                userId: req._auth.verifiedAuth.claims.userId,
+                onUsage: (rounds) => {
+                    mercuryRounds.push(...rounds);
+                },
+                personWords,
+                words: briefWords,
+                style: mercuryStyleFor(mercuryVariant),
+                juice: mercuryJuiceFor(mercuryVariant),
+                depth: mercuryDepthFor(mercuryVariant),
+                reply: mercuryReplyFor(mercuryVariant),
+                duo: mercuryDuoFor(mercuryVariant),
+                ...(mercuryDuoPoolFor(mercuryVariant) === undefined ? {} : { duoPool: mercuryDuoPoolFor(mercuryVariant) }),
+                oneCall: mercuryOneCallFor(mercuryVariant),
+                recordsRules: mercuryRecordsRulesFor(mercuryVariant),
+                ...(mercuryPlannerNamed === undefined ? {} : { planner: mercuryPlannerNamed }),
+                ...(mercuryFormat === "skeleton" ? {} : { format: mercuryFormat }),
+                rooms: poufLookFor(vctx, req._auth.verifiedAuth.claims.userId),
+                ...(mercurySwitched ? { rateLimitedBudgetMs: MERCURY_RATE_LIMITED_STAGE_MS } : {}),
+                ...(mercuryKeepText ? { keepText: true } : {}),
+            })
+            : undefined;
         let briefCallPending = briefArmed;
         let briefAddressRetried = false;
         let briefContinueOwed = false;
@@ -74,8 +131,10 @@ export function createAgentTurnAction(args) {
                 ? { ownerHandle: resChat.ownerHandle }
                 : { ownerHandle: resChat.ownerHandle, appSlug: resChat.appSlug },
         });
-        if (rActor.isErr())
+        if (rActor.isErr()) {
+            mercuryCancel.abort();
             return Result.Err(rActor.Err());
+        }
         const surveyColorway = startFirstTurnImageSurvey(vctx, {
             guard: liveSession,
             firstTurn: agentFirstTurnMint,
@@ -96,8 +155,10 @@ export function createAgentTurnAction(args) {
         let liveAppSlug = resChat.appSlug;
         let firstTurnAppClaimed = agentFirstTurnMint === false;
         const rVfs = await pVfs;
-        if (rVfs.isErr())
+        if (rVfs.isErr()) {
+            mercuryCancel.abort();
             return Result.Err(rVfs.Err());
+        }
         const vfs = new Map(rVfs.Ok());
         function extendDeadlineForAwaitedBuild(awaiting) {
             void extendOpenTurnDeadline(vctx.sql, {
@@ -115,6 +176,7 @@ export function createAgentTurnAction(args) {
             });
         }
         const firstTurnFileBlocks = userFileBlocks(orig.prompt.messages);
+        const turnCarry = isMercuryVariant(instructionVariant) ? carryWithoutVariant(dispatchCarry) : dispatchCarry;
         const dispatcherBase = {
             vctx,
             host: ctx,
@@ -128,10 +190,9 @@ export function createAgentTurnAction(args) {
                 extendDeadlineForAwaitedBuild(t.promptId);
                 return t.chatId === req.chatId ? liveSession.watch(t.promptId) : liveSession.watchBuild(t);
             },
-            ...(Object.keys(dispatchCarry).length === 0 ? {} : { carry: dispatchCarry }),
+            ...(Object.keys(turnCarry).length === 0 ? {} : { carry: turnCarry }),
         };
-        const dispatcher = createAgentBuildDispatcher({
-            ...dispatcherBase,
+        const firstTurnDispatch = {
             ...(agentFirstTurnMint
                 ? {
                     firstTurn: {
@@ -147,7 +208,16 @@ export function createAgentTurnAction(args) {
                     },
                 }
                 : {}),
-        });
+        };
+        const dispatcher = createAgentBuildDispatcher({ ...dispatcherBase, ...firstTurnDispatch });
+        const mercuryDispatcher = mercuryPending === undefined
+            ? dispatcher
+            : createAgentBuildDispatcher({
+                ...dispatcherBase,
+                ...(Object.keys(dispatchCarry).length === 0 ? {} : { carry: dispatchCarry }),
+                ...firstTurnDispatch,
+                ...(mercurySwitched ? { mercuryFont: true } : {}),
+            });
         const evidence = agentEvidence ??
             observeEvidenceLine(createAgentEvidenceWriter({
                 chatId: req.chatId,
@@ -183,6 +253,163 @@ export function createAgentTurnAction(args) {
                 firstTurnAppClaimed = true;
             }
         }
+        const seamTask = mercuryPending !== undefined && race !== undefined && firstTurnMint !== undefined && topLevel === false
+            ? runMercurySeam(vctx, {
+                pending: mercuryPending,
+                actor: rActor.Ok(),
+                dispatcher: mercuryDispatcher,
+                firstTurn: firstTurnMint,
+                ...(surveyColorway?.colorway === undefined ? {} : { presetColorway: surveyColorway.colorway }),
+                style: mercuryStyleFor(mercuryVariant),
+                juice: mercuryJuiceFor(mercuryVariant),
+                depth: mercuryDepthFor(mercuryVariant),
+                reply: mercuryReplyFor(mercuryVariant),
+                duo: mercuryDuoFor(mercuryVariant),
+                oneCall: mercuryOneCallFor(mercuryVariant),
+                recordsRules: mercuryRecordsRulesFor(mercuryVariant),
+                ...(mercuryPlannerNamed === undefined ? {} : { planner: mercuryPlannerNamed }),
+                ...(mercuryFormat === "skeleton" ? {} : { format: mercuryFormat }),
+                ...(mercurySwitched ? { productionSwitch: true } : {}),
+                ...(mercuryKeepText ? { keepText: true } : {}),
+                race,
+                evidence,
+            })
+                .catch((e) => {
+                race.mercurySettled(false);
+                race.settleMercury({ dispatched: false });
+                vctx.logger.Warn().Err(e).Str("chatId", req.chatId).Msg("mercury-seam-threw");
+                return { dispatched: false, reason: "mercury-failed" };
+            })
+                .then(async (outcome) => {
+                if (outcome.dispatched) {
+                    liveAppSlug = outcome.appSlug;
+                    liveSession.claimAppAddress(outcome.appSlug);
+                    firstTurnAppClaimed = true;
+                }
+                if (lastMercuryRow !== undefined)
+                    await recordMercuryRace(vctx, { chatId: req.chatId, promptId: lastMercuryRow, race: race.receipt() });
+                return outcome;
+            })
+            : undefined;
+        const preJoin = createPreJoinRounds();
+        let roundText = "";
+        let alternativeRecorded = false;
+        function raceRound(stream) {
+            if (race === undefined || preJoin.open() === false)
+                return stream;
+            const tag = preJoin.startRound();
+            roundText = "";
+            let calledTool = false;
+            return stream.pipeThrough(new TransformStream({
+                transform(msg, controller) {
+                    if (isSseLine(msg)) {
+                        for (const choice of msg.chunk.choices) {
+                            if (choice.delta.tool_calls !== undefined)
+                                calledTool = true;
+                            const content = choice.delta.content;
+                            if (typeof content === "string")
+                                roundText += content;
+                        }
+                        controller.enqueue({ ...msg, chunk: { ...msg.chunk, id: tag } });
+                        return;
+                    }
+                    if (isSseEnd(msg) && calledTool === false) {
+                        race.agentAnswered();
+                        preJoin.answered(tag);
+                    }
+                    controller.enqueue(msg);
+                },
+            }));
+        }
+        const beltFirstTurn = firstTurnMint === undefined || race === undefined
+            ? firstTurnMint
+            : {
+                ...firstTurnMint,
+                joinRunning: async () => {
+                    const decision = await race.agentCreate();
+                    if (decision.kind !== "join")
+                        return undefined;
+                    preJoin.joined();
+                    await evidence({
+                        kind: "receipt",
+                        name: FIRST_BUILD_RACE_EVIDENCE_NAME,
+                        text: JSON.stringify({ race: race.receipt() }),
+                    });
+                    return joinedFirstBuildReceipt(decision);
+                },
+                startAlternative: async (input) => {
+                    if (race.receipt().alternative !== undefined)
+                        return { dispatched: false };
+                    race.noteAlternative({ dispatched: false });
+                    const originLabel = `${resChat.ownerHandle}/${liveAppSlug}`;
+                    const alternativeLabel = new Future();
+                    const started = await startAlternativeFirstBuild(vctx, {
+                        actor: rActor.Ok(),
+                        openAuth: { auth: req.auth, _auth: req._auth },
+                        input,
+                        prompt: personWords,
+                        personWords,
+                        ...(roundText.trim().length === 0 ? {} : { opener: roundText }),
+                        originLabel,
+                        originChatId: req.chatId,
+                        dispatcherFor: (altChatId) => createAgentBuildDispatcher({
+                            ...dispatcherBase,
+                            firstTurn: {
+                                chatId: altChatId,
+                                ...(submittedAt === undefined ? {} : { submittedAt }),
+                                ...(firstTurnFileBlocks.length === 0 ? {} : { fileBlocks: firstTurnFileBlocks }),
+                            },
+                            takeFileBlocks: () => [],
+                            callerSlot: { tryTake: () => undefined },
+                            onPendingBuild: (t) => {
+                                watchAlternativeLanding(vctx, {
+                                    chatId: t.chatId,
+                                    promptId: t.promptId,
+                                    originChatId: req.chatId,
+                                    onLanded: async (landed) => {
+                                        race.noteAlternative({ landed });
+                                        if (alternativeRecorded && lastMercuryRow !== undefined)
+                                            await recordMercuryRace(vctx, { chatId: req.chatId, promptId: lastMercuryRow, race: race.receipt() });
+                                        const note = alternativeReadyNote(landed, await alternativeLabel.asPromise());
+                                        if (note === undefined)
+                                            return;
+                                        vctx.logger
+                                            .Info()
+                                            .Any("event", { chatId: req.chatId, alternativeChatId: t.chatId, promptId: t.promptId })
+                                            .Msg("alternative-first-build-wake-firing");
+                                        fireAgentWakeTurn({
+                                            vctx,
+                                            host: ctx,
+                                            auth: req.auth,
+                                            outerTid: req.outerTid,
+                                            chatId: req.chatId,
+                                            budget: 0,
+                                            note,
+                                            ...(turnCarry.builderModel === undefined ? {} : { builderModel: turnCarry.builderModel }),
+                                            ...(turnCarry.subagentModel === undefined ? {} : { subagentModel: turnCarry.subagentModel }),
+                                            ...(turnCarry.agentModel === undefined ? {} : { agentModel: turnCarry.agentModel }),
+                                            ...(turnCarry.timeZone === undefined ? {} : { timeZone: turnCarry.timeZone }),
+                                            handle: (wakeCtx) => reenter(promptDispatchContext(ctx, wakeCtx.validated)),
+                                        });
+                                    },
+                                });
+                            },
+                        }),
+                    });
+                    alternativeLabel.resolve(started.dispatched ? started.label : undefined);
+                    race.noteAlternative(started.dispatched
+                        ? { dispatched: true, chatId: started.chatId, appSlug: started.appSlug, landed: "pending" }
+                        : {
+                            dispatched: false,
+                            ...(started.chatId === undefined ? {} : { chatId: started.chatId }),
+                            landed: started.skipped,
+                        });
+                    return { dispatched: started.dispatched };
+                },
+            };
+        function serverCreatedFrame(messages) {
+            return serverFirstBuildAppContext(messages, { ownerHandle: resChat.ownerHandle, appSlug: liveAppSlug });
+        }
         const poufApp = agentFirstTurnMint === false && topLevel === false && poufLookFor(vctx, rActor.Ok().userId)
             ? await exception2Result(() => readComposedSettingsForApp(vctx, resChat.ownerHandle, resChat.appSlug)).then((r) => r.isOk() && r.Ok().find(isActiveTheme)?.theme === "pouf")
             : false;
@@ -190,6 +417,7 @@ export function createAgentTurnAction(args) {
             ? createAccountAgentBelt(vctx, {
                 actor: rActor.Ok(),
                 chatId: req.chatId,
+                personWords,
                 openAuth: { auth: req.auth, _auth: req._auth },
                 dispatcher,
                 mintDispatcherFor: (mintChatId) => createAgentBuildDispatcher({
@@ -208,12 +436,12 @@ export function createAgentTurnAction(args) {
             : createAgentBelt(vctx, {
                 actor: rActor.Ok(),
                 chatId: req.chatId,
+                personWords,
                 vfs,
-                onOptionsOffered: (offered) => evidence({ kind: "options", options: [...offered] }),
                 ...(poufApp ? { poufApp } : {}),
-                ...(firstTurnMint === undefined
+                ...(beltFirstTurn === undefined
                     ? {}
-                    : { firstTurn: serverCreated === undefined ? firstTurnMint : { ...firstTurnMint, preCreated: serverCreated } }),
+                    : { firstTurn: serverCreated === undefined ? beltFirstTurn : { ...beltFirstTurn, preCreated: serverCreated } }),
                 ...(agentFetchUrlContext === undefined ? {} : { fetchUrl: agentFetchUrlContext }),
                 dispatcher,
                 queueEdit: (input) => liveSession.queue(input),
@@ -254,6 +482,7 @@ export function createAgentTurnAction(args) {
                     });
                 },
                 onDispatch: (dispatched) => {
+                    preJoin.joined();
                     liveAppSlug = dispatched.appSlug;
                     liveSession.claimAppAddress(dispatched.appSlug);
                     firstTurnAppClaimed = true;
@@ -294,7 +523,7 @@ export function createAgentTurnAction(args) {
                             : seededWordsArmed
                                 ? withSeededAddressWordsLine(agentPayload.messages, briefWords)
                                 : agentPayload.messages
-                        : serverFirstBuildAppContext(agentPayload.messages, { ownerHandle: resChat.ownerHandle, appSlug: liveAppSlug }),
+                        : serverCreatedFrame(agentPayload.messages),
                     model: agentPayload.model,
                     ownerHandle: resChat.ownerHandle,
                     appSlug: liveAppSlug,
@@ -320,9 +549,34 @@ export function createAgentTurnAction(args) {
         const rSse = createProviderSseStream(res.res, promptId);
         if (rSse.isErr()) {
             vctx.logger.Warn().Err(rSse).Str("chatId", req.chatId).Msg("agent-turn-provider-stream-unavailable");
+            race?.agentFailed();
         }
         else {
-            providerStream = createAgentTurnStream({
+            const roundOne = briefArmed
+                ? observeFirstBriefRound(rSse.Ok(), {
+                    startedAt: briefStartedAt,
+                    now: () => Date.now(),
+                    onEnd: async (round) => {
+                        briefRound = round;
+                        if (race !== undefined && round.called && (await race.agentCreate()).kind === "join") {
+                            briefRecorded = true;
+                            return;
+                        }
+                        await recordFirstBriefRow(vctx, {
+                            chatId: req.chatId,
+                            userId: req._auth.verifiedAuth.claims.userId,
+                            model: briefModel,
+                            round,
+                        });
+                        if (round.called === false) {
+                            briefCallPending = false;
+                            briefContinueOwed = true;
+                            await recordBrief({ dispatched: false, reason: "no-create-call" });
+                        }
+                    },
+                })
+                : rSse.Ok();
+            const turnStream = createAgentTurnStream({
                 vctx,
                 belt,
                 actor: rActor.Ok(),
@@ -330,27 +584,21 @@ export function createAgentTurnAction(args) {
                 vfs,
                 dispatcher,
                 request: res.llmReq,
-                stream: briefArmed
-                    ? observeFirstBriefRound(rSse.Ok(), {
-                        startedAt: briefStartedAt,
-                        now: () => Date.now(),
-                        onEnd: async (round) => {
-                            briefRound = round;
-                            await recordFirstBriefRow(vctx, {
-                                chatId: req.chatId,
-                                userId: req._auth.verifiedAuth.claims.userId,
-                                model: briefModel,
-                                round,
-                            });
-                            if (round.called === false) {
-                                briefCallPending = false;
-                                briefContinueOwed = true;
-                                await recordBrief({ dispatched: false, reason: "no-create-call" });
-                            }
-                        },
-                    })
-                    : rSse.Ok(),
+                stream: raceRound(roundOne),
                 abort: res.abort,
+                settleOptionLines: createAgentClosingOptions(vctx, {
+                    actor: rActor.Ok(),
+                    chatId: req.chatId,
+                    ...(topLevel ? { noApp: true } : {}),
+                    onOffered: (row) => {
+                        race?.noteChips(row.options.length);
+                        return evidence({
+                            kind: "options",
+                            options: [...row.options],
+                            text: JSON.stringify({ asked: row.asked, dropped: row.dropped }),
+                        });
+                    },
+                }),
                 onToolEvidence: async ({ kind, call, text, round, epoch }) => {
                     const written = await evidence({ kind, callId: call.id, name: call.name, text, round, epoch });
                     if (briefRecorded === false && kind === "receipt" && call.name === "create_vibe" && round === 1 && epoch === 0) {
@@ -390,7 +638,7 @@ export function createAgentTurnAction(args) {
                     const framed = agentFirstTurnMint && firstTurnAppClaimed
                         ? serverCreated === undefined
                             ? claimAgentAppContext(request.messages, { ownerHandle: resChat.ownerHandle, appSlug: liveAppSlug })
-                            : serverFirstBuildAppContext(request.messages, { ownerHandle: resChat.ownerHandle, appSlug: liveAppSlug })
+                            : serverCreatedFrame(request.messages)
                         : request.messages;
                     const messages = await inflateAgentFiles(vctx, {
                         messages: briefArmed || seededWordsArmed ? withoutFirstBriefLine(framed) : framed,
@@ -441,14 +689,24 @@ export function createAgentTurnAction(args) {
                         return Result.Err(rRound);
                     return Result.Ok({
                         request: { ...loopReq, messages },
-                        stream: rRound.Ok(),
+                        stream: raceRound(rRound.Ok()),
                         abort: dispatch.abort,
                     });
                 },
                 onError: (error) => {
                     vctx.logger.Warn().Any("event", { chatId: req.chatId, promptId, error }).Msg("agent-turn-loop-failed");
+                    race?.agentFailed();
+                    preJoin.close();
                 },
             });
+            providerStream =
+                race === undefined || mercuryPending === undefined
+                    ? turnStream
+                    : deferredStream(race.decided.then((verdict) => {
+                        const preamble = verdict === "mercury" ? race.mercuryPreamble() : undefined;
+                        const shown = preamble !== undefined ? withPreambleFirst(withoutPreJoinText(turnStream, preJoin), preamble) : turnStream;
+                        return withMercuryUsageRounds(shown, { settled: mercuryPending, rounds: () => mercuryRounds });
+                    }));
         }
         const finalBlockSeq = await handleLlmResponse({
             scope,
@@ -469,6 +727,12 @@ export function createAgentTurnAction(args) {
             platformInitiated: agentWakeTurn,
             step: agentWakeTurn ? "wake" : "agent",
         });
+        if (seamTask !== undefined)
+            await seamTask;
+        if (race !== undefined && lastMercuryRow !== undefined) {
+            await recordMercuryRace(vctx, { chatId: req.chatId, promptId: lastMercuryRow, race: race.receipt() });
+            alternativeRecorded = true;
+        }
         return Result.Ok(finalBlockSeq);
     };
 }
@@ -617,4 +881,8 @@ async function commitStagedFiles(args) {
         ...(designCheck === undefined ? {} : { designCheck }),
     });
 }
+function carryWithoutVariant(carry) {
+    const { instructionVariant: _variant, ...rest } = carry;
+    return rest;
+}
 //# sourceMappingURL=agent-turn-action.js.map