@vibes.diy/api-svc 14.3.16 → 14.3.18

package/public/prompt-chat-section.js

@@ -2,130 +2,32 @@ import { checkBuildAuth } from "../check-build-auth.js";
 import { handleGuestPrompt } from "./guest-build-generation.js";
 import { Result, Option, EventoResult, exception2Result } from "@adviser/cement";
 import { scopey } from "@adviser/scopey";
-import { isReqCreationPromptChatSection, isReqPromptApplicationChatSection, isReqPromptFSChatSection, isReqPromptImageChatSection, isReqPromptLLMChatSection, reqPromptChatSection, canonicalModelUsage, isBuildNotifyMode, isSourceChangingMode, shouldNotify, RESEARCH_BLOCK_SEQ, } from "@vibes.diy/api-types";
+import { isReqCreationPromptChatSection, reqPromptChatSection, isBuildNotifyMode, isSourceChangingMode, } from "@vibes.diy/api-types";
 import { type } from "arktype";
-import { captureAccessVerdicts, captureCodegenTurnSettled } from "../analytics.js";
-import { releaseAccessVerdicts } from "../intern/access-verdict-docs.js";
-import { renderAccessVerdictLine } from "../intern/access-verdicts.js";
-import { dispatchLookLint, loadTurnFilesByFsId, lookLintPlanned } from "../intern/look-lint.js";
-import { postMakerFact } from "../intern/post-maker-fact.js";
-import { postCapiBuildEvent } from "../intern/capi-build-event.js";
-import { classifyTurnReach, projectTurnReach } from "../intern/turn-reach.js";
-import { loadNotificationPrefs } from "../intern/notification-prefs.js";
-import { resolveBuildOrdinal } from "../intern/build-version-ordinal.js";
 import { checkAuth } from "../check-auth.js";
 import { unwrapMsgBase, wrapMsgBase } from "../unwrap-msg-base.js";
 import { assertChatShardIdentity } from "../shard-gate.js";
-import { and, eq, ne } from "drizzle-orm/sql/expressions";
-import { isChatMessage, isUserChatMessage } from "@vibes.diy/call-ai-v2";
-import { getModelDefaults } from "../intern/get-model-defaults.js";
-import { resolveSlotConfig } from "../intern/slot-assembler.js";
-import { dryRunHandleIsForeign } from "../intern/ensure-chat-id.js";
-import { resolveDeveloperAccess } from "./developer-grants.js";
 import { createPromptAssetFetch, promptsPkgBaseUrl } from "../intern/prompt-asset-fetch.js";
 import { resolveCodeBlocksToFileSystem, resolveCodeBlockChangedPaths, createStreamingResolver, createBlockAccumulator, logApplyError, } from "../intern/prompt-streaming.js";
 import { reconstructConversationMessages, assemblePromptPayload, persistCodegenThemeMarker, ELIDED_CODE_NOTICE, } from "../intern/prompt-assembly.js";
 import { bumpAppRecency } from "../intern/bump-app-recency.js";
 import { waitChatPersistIdle } from "../intern/chat-persist-gate.js";
-import { peekInFlightTurns } from "../intern/in-flight-turns.js";
-import { acquireTurnBuildLock, peekBuildLockEntry, releaseTurnBuildLock } from "../intern/codegen-build-lock.js";
-import { deliverAgentSession } from "../intern/agent-session-runtime.js";
-import { readAgentSession } from "../intern/agent-session-store.js";
-import { runEditVibeTool } from "../intern/agent-build-tools.js";
-import { claimFirstTurnMint, claimMintJob, getMintJob } from "../intern/mint-job-store.js";
-import { codegenTurnLane, mintRowSaysFirstTurnIsAgents, routeAgentTurn } from "../intern/agent-router.js";
-import { assembleAgentPayload } from "../intern/agent-assembly.js";
-import { claimAgentAppContext, composeAgentRequest, isAppContextMessage, markJournalCacheTail, } from "../intern/agent-request-frame.js";
-import { createAgentBelt } from "../intern/agent-belt.js";
-import { createAgentTurnStream, agentTotalBudgetMs } from "../intern/agent-turn.js";
-import { createAgentBuildDispatcher } from "../intern/agent-dispatcher.js";
-import { decideAgentWake, fireAgentWakeTurn, readAgentWakeBudget, renderAgentWakeNote } from "../intern/agent-wake.js";
-import { settleTurnTerminal } from "../intern/turn-terminal.js";
-import { resolveAgentActor, resolveChatApp } from "../intern/agent-actor.js";
-import { langForFilename } from "../intern/ensure-push-seeded-chat.js";
-import { promptDispatchContext } from "../intern/prompt-dispatch-context.js";
-import { dispatchLlmRequestWithFallback } from "./llm-dispatch.js";
-import { scheduleUrlResearch } from "../intern/url-research-queue.js";
-import { createProviderSseStream } from "../intern/provider-sse.js";
-import { activateWorkUrls, loadWorkFetchUrlContext, loadWorkVfs, withoutServerTools } from "../intern/work-tools.js";
-import { closeTurn, extendOpenTurnDeadline, OPEN_TURN_AWAIT_BUILD_EXTENSION_MS, shouldCloseTurnRecord, } from "../intern/open-turn-store.js";
-import { maxPersistedBlockSeq } from "../intern/persisted-block-seq.js";
-import { appendBlockEvent, currentUserMessageText, handlerLlmRequest } from "./llm-dispatch.js";
-import { createAgentEvidenceWriter, nextAgentSessionMessages } from "../intern/agent-evidence.js";
-import { msSinceOrigin, observeEvidenceLine } from "../intern/turn-latency.js";
-import { handleLlmResponse } from "./stream-assembly.js";
-import { handleProdiaImageRequest } from "./image-gen.js";
+import { acquireTurnBuildLock, releaseTurnBuildLock } from "../intern/codegen-build-lock.js";
+import { agentSessionPinsFor } from "../intern/agent-session.js";
+import { decideAgentWake } from "../intern/agent-wake.js";
+import { appendBlockEvent } from "./llm-dispatch.js";
 import { handleFSPrompt } from "./fs-prompt.js";
-import { admitBuilderModel, dispatchCarryFor } from "../intern/builder-model.js";
-import { admitInstructionVariant } from "../intern/instruction-variant.js";
-import { evalWakeAgentModel } from "../intern/eval-handles.js";
-import { promptStepFor } from "../intern/prompt-step.js";
-function clientWsSend(ctx) {
-    return ctx.send.provider;
-}
+import { admitTurnOptions, getResChatFromMode, readTurnEnvelope } from "./prompt-turn-envelope.js";
+import { assembleCodegenTurn, routeCodegenTurn } from "./codegen-turn-route.js";
+import { assembleAgentTurn } from "./agent-turn-assembly.js";
+import { resolveImageModel, selectPromptSectionAction } from "./prompt-section-actions.js";
+import { finalizePromptTurn, recordTurnError } from "./prompt-turn-terminal.js";
+import { settlePromptTurn } from "./prompt-turn-settled.js";
 export { createPromptAssetFetch, promptsPkgBaseUrl };
 export { resolveCodeBlocksToFileSystem, resolveCodeBlockChangedPaths, createStreamingResolver, createBlockAccumulator, logApplyError, };
 export { reconstructConversationMessages, assemblePromptPayload, persistCodegenThemeMarker, ELIDED_CODE_NOTICE };
 export { handlePromptContext } from "./llm-dispatch.js";
 export { handleFSPrompt };
-async function getResChatFromMode(vctx, req, orig) {
-    if (isReqCreationPromptChatSection(orig) &&
-        orig.dryRun === true &&
-        orig.ownerHandle !== undefined &&
-        orig.appSlug !== undefined) {
-        const anyRow = await vctx.sql.db
-            .select({ chatId: vctx.sql.tables.chatContexts.chatId })
-            .from(vctx.sql.tables.chatContexts)
-            .where(eq(vctx.sql.tables.chatContexts.chatId, req.chatId))
-            .limit(1)
-            .then((r) => r[0]);
-        if (!anyRow) {
-            const userId = req._auth.verifiedAuth.claims.userId;
-            const rForeign = await dryRunHandleIsForeign(vctx, orig.ownerHandle, userId);
-            if (rForeign.isErr())
-                return Result.Err(rForeign);
-            if (rForeign.Ok()) {
-                const dev = orig.appSlug !== undefined
-                    ? await resolveDeveloperAccess(vctx, { ownerHandle: orig.ownerHandle, appSlug: orig.appSlug, callerUserId: userId })
-                    : null;
-                if (dev === null) {
-                    return Result.Err(`ownerHandle "${orig.ownerHandle}" is owned by another user`);
-                }
-            }
-            return Result.Ok({ appSlug: orig.appSlug, ownerHandle: orig.ownerHandle, mode: orig.mode });
-        }
-    }
-    let iResChat;
-    if (isReqPromptApplicationChatSection(orig) || isReqPromptImageChatSection(orig)) {
-        iResChat = await vctx.sql.db
-            .select()
-            .from(vctx.sql.tables.applicationChats)
-            .where(and(eq(vctx.sql.tables.applicationChats.userId, req._auth.verifiedAuth.claims.userId), eq(vctx.sql.tables.applicationChats.chatId, req.chatId)))
-            .limit(1)
-            .then((r) => r[0]);
-    }
-    else {
-        iResChat = await vctx.sql.db
-            .select()
-            .from(vctx.sql.tables.chatContexts)
-            .where(and(eq(vctx.sql.tables.chatContexts.userId, req._auth.verifiedAuth.claims.userId), eq(vctx.sql.tables.chatContexts.chatId, req.chatId)))
-            .limit(1)
-            .then((r) => r[0]);
-    }
-    if (!iResChat) {
-        if (isReqCreationPromptChatSection(orig)) {
-            return Result.Err(`Creation Chat ID ${req.chatId} not found`);
-        }
-        else if (isReqPromptApplicationChatSection(orig)) {
-            return Result.Err(`Application Chat ID ${req.chatId} not found`);
-        }
-        else if (isReqPromptImageChatSection(orig)) {
-            return Result.Err(`Image Chat ID ${req.chatId} not found`);
-        }
-    }
-    const resChat = { ...iResChat, mode: orig.mode };
-    return Result.Ok(resChat);
-}
 const accountPromptChatSection = {
     hash: "prompt-chat-section-handler",
     validate: unwrapMsgBase(async (msg) => {
@@ -143,829 +45,117 @@ const accountPromptChatSection = {
         const orig = ctx.enRequest.payload;
         const vctx = ctx.ctx.getOrThrow("vibesApiCtx");
         const turnStartedAt = Date.now();
-        const submittedAtRaw = orig.submittedAt;
-        const submittedAt = typeof submittedAtRaw === "number" &&
-            Number.isFinite(submittedAtRaw) &&
-            submittedAtRaw <= turnStartedAt &&
-            turnStartedAt - submittedAtRaw <= 3_600_000
-            ? submittedAtRaw
-            : undefined;
-        const directBuildRequested = orig.directBuild === true;
-        const agentDispatchedBuild = orig.agentDispatched === true;
-        const agentWakeTurn = orig.agentWake === true;
-        const agentWakeBudget = readAgentWakeBudget(orig.agentWakeBudget);
-        const agentWakeNoteRaw = orig.agentWakeNote;
-        const agentWakeNote = agentWakeTurn === true && typeof agentWakeNoteRaw === "string" ? agentWakeNoteRaw : undefined;
-        const firstTurnAgent = orig.firstTurnAgent === true;
-        const nonInteractive = orig.nonInteractive === true;
-        let agentFetchUrlContext;
+        const envelope = readTurnEnvelope(orig, turnStartedAt);
+        const { agentDispatchedBuild, agentWakeBudget } = envelope;
         await waitChatPersistIdle(vctx.connections, req.chatId, { logger: vctx.logger });
         const rResChat = await getResChatFromMode(vctx, req, orig);
         if (rResChat.isErr()) {
             return Result.Err(rResChat);
         }
         const resChat = rResChat.Ok();
-        const rInstructionVariant = admitInstructionVariant(orig.instructionVariant, resChat.ownerHandle);
-        if (rInstructionVariant.isErr())
-            return Result.Err(rInstructionVariant);
-        const instructionVariant = rInstructionVariant.Ok();
-        const rBuilderModel = await admitBuilderModel(vctx, orig.builderModel, resChat.ownerHandle);
-        if (rBuilderModel.isErr())
-            return Result.Err(rBuilderModel);
-        const builderModel = rBuilderModel.Ok();
-        const dispatchCarry = dispatchCarryFor({
-            apiKey: orig.apiKey,
-            model: orig.prompt?.model,
-            ...(builderModel === undefined ? {} : { builderModel }),
-            focusPath: orig.focusPath,
-            ...(instructionVariant === undefined ? {} : { instructionVariant }),
-        });
-        const wakeAgentModel = evalWakeAgentModel(resChat.ownerHandle, orig.agentModel);
+        const rAdmitted = await admitTurnOptions(vctx, orig, resChat);
+        if (rAdmitted.isErr())
+            return Result.Err(rAdmitted);
+        const { instructionVariant, builderModel, subagentModel, dispatchCarry, wakeAgentModel } = rAdmitted.Ok();
         const oShardErr = assertChatShardIdentity(ctx, resChat.ownerHandle, resChat.appSlug);
         if (oShardErr.IsSome()) {
             await ctx.send.send(ctx, oShardErr.unwrap());
             return Result.Ok(EventoResult.Continue);
         }
         let preAssembled;
-        let turnToolsOffered = [];
         let agentAssembled;
         let agentSession;
         let agentEvidence;
+        let agentFetchUrlContext;
         const turnLatency = {};
         let agentFirstTurnMint = false;
-        let lightMintedChat = false;
-        let mintUnclaimed = false;
+        let subagentCall;
+        const facts = { toolsOffered: [], errored: false };
         if (isReqCreationPromptChatSection(orig)) {
-            if (agentWakeTurn === false && !orig.prompt.messages.some((m) => m.role === "user")) {
-                return Result.Err(`prompt.messages must include at least one user message`);
-            }
-            const rDefaults = await getModelDefaults(vctx, { appSlug: resChat.appSlug, ownerHandle: resChat.ownerHandle });
-            if (rDefaults.isErr())
-                return Result.Err(rDefaults);
-            const modelId = orig.prompt.model ?? rDefaults.Ok().codegen.model.id;
-            let hasPriorTurn = false;
-            if (orig.dryRun !== true) {
-                const rPrior = await exception2Result(() => vctx.sql.db
-                    .select({ chatId: vctx.sql.tables.chatSections.chatId })
-                    .from(vctx.sql.tables.chatSections)
-                    .where(and(eq(vctx.sql.tables.chatSections.chatId, req.chatId), ne(vctx.sql.tables.chatSections.blockSeq, RESEARCH_BLOCK_SEQ)))
-                    .limit(1)
-                    .then((r) => r[0]));
-                if (rPrior.isErr()) {
-                    vctx.logger.Warn().Err(rPrior).Msg("follow-up probe: chatSections read failed; treating turn as initial");
-                }
-                else {
-                    hasPriorTurn = rPrior.Ok() !== undefined;
-                }
-            }
-            const routeInput = {
-                codegenChatTurn: true,
-                dryRun: orig.dryRun === true,
-                directBuildRequested,
-                agentWake: agentWakeTurn,
-                hasPriorTurn,
-                firstTurnAgent,
-            };
-            let agentRoute = routeAgentTurn(routeInput);
-            const mintRowWorthReading = (agentRoute.route === "codegen" && agentRoute.skip === "first-turn") ||
-                (agentRoute.route === "agent" && hasPriorTurn === true);
-            if (mintRowWorthReading) {
-                const rJob = await getMintJob(vctx, req.chatId);
-                if (rJob.isErr()) {
-                    vctx.logger
-                        .Warn()
-                        .Err(rJob)
-                        .Str("chatId", req.chatId)
-                        .Msg("first-turn mint-job read failed; keeping the codegen route");
-                }
-                else if (mintRowSaysFirstTurnIsAgents(rJob.Ok()?.status)) {
-                    mintUnclaimed = true;
-                    if (agentRoute.route === "codegen") {
-                        lightMintedChat = true;
-                        agentRoute = routeAgentTurn({ ...routeInput, firstTurnAgent: true });
-                    }
-                }
-            }
-            agentFirstTurnMint =
-                agentRoute.route === "agent" &&
-                    (firstTurnAgent || lightMintedChat || mintUnclaimed) &&
-                    (hasPriorTurn === false || mintUnclaimed);
-            if (agentRoute.route === "agent") {
-                agentFetchUrlContext = await loadWorkFetchUrlContext(vctx, {
-                    userId: req._auth.verifiedAuth.claims.userId,
-                    chatId: req.chatId,
-                    ownerHandle: resChat.ownerHandle,
-                    appSlug: resChat.appSlug,
-                    activatedUrls: activateWorkUrls(currentUserMessageText(orig.prompt.messages.filter(isChatMessage))),
-                });
-                const buildInFlight = peekBuildLockEntry(vctx.connections, req.chatId);
-                const rSeenHead = await readAgentSession(vctx.sql, req.chatId);
-                if (rSeenHead.isErr())
-                    vctx.logger.Warn().Err(rSeenHead).Str("chatId", req.chatId).Msg("agent-session-head-read-failed");
-                const lastSeenHeadFsId = rSeenHead.isOk() ? rSeenHead.Ok().snapshot?.headFsId : undefined;
-                const rAgent = await assembleAgentPayload(vctx, {
-                    chatId: req.chatId,
-                    userId: req._auth.verifiedAuth.claims.userId,
-                    model: orig.prompt.model ?? rDefaults.Ok().agent.model.id,
-                    ownerHandle: resChat.ownerHandle,
-                    appSlug: resChat.appSlug,
-                    newUserMessages: orig.prompt.messages.filter(isChatMessage),
-                    ...(agentWakeNote === undefined ? {} : { wakeNote: agentWakeNote }),
-                    ...(buildInFlight === undefined ? {} : { buildInFlight: { promptId: buildInFlight.promptId } }),
-                    ...(agentFirstTurnMint ? { noAppYet: true } : {}),
-                    ...(nonInteractive ? { nonInteractive: true } : {}),
-                    ...(lastSeenHeadFsId === undefined ? {} : { lastSeenHeadFsId }),
-                    ...(instructionVariant === undefined ? {} : { instructionVariant }),
+            const rRoute = await routeCodegenTurn(vctx, {
+                req,
+                orig,
+                resChat,
+                envelope,
+                ...(subagentModel === undefined ? {} : { subagentModel }),
+            });
+            if (rRoute.isErr())
+                return Result.Err(rRoute);
+            const route = rRoute.Ok();
+            agentFirstTurnMint = route.agentFirstTurnMint;
+            subagentCall = route.subagentCall;
+            if (route.agentRoute.route === "agent") {
+                const rAgent = await assembleAgentTurn({
+                    ctx,
+                    vctx,
+                    req,
+                    orig,
+                    resChat,
+                    defaults: route.defaults,
+                    envelope,
+                    agentFirstTurnMint,
+                    instructionVariant,
+                    turnLatency,
+                    pins: agentSessionPinsFor(dispatchCarry),
                 });
                 if (rAgent.isErr())
                     return Result.Err(rAgent);
-                agentAssembled = { model: rAgent.Ok().model, messages: rAgent.Ok().messages };
-                const rawIncoming = orig.prompt.messages.filter(isUserChatMessage);
-                const newMessageCount = orig.prompt.messages.filter(isChatMessage).length;
-                const incoming = newMessageCount === 0 ? [] : rAgent.Ok().messages.slice(-newMessageCount).filter(isUserChatMessage);
-                const delivered = incoming.length === 0 && agentWakeTurn
-                    ? [
-                        {
-                            role: "user",
-                            content: [
-                                {
-                                    type: "text",
-                                    text: agentWakeNote ??
-                                        "[session resumed] Continue from your persisted context and pending results. Inspect outcomes before retrying interrupted tools.",
-                                },
-                            ],
-                        },
-                    ]
-                    : incoming;
-                const acquired = await deliverAgentSession(vctx, {
-                    chatId: req.chatId,
-                    userId: req._auth.verifiedAuth.claims.userId,
-                    ownerHandle: resChat.ownerHandle,
-                    appSlug: resChat.appSlug,
-                }, { id: ctx.validated.tid, messages: delivered }, rAgent.Ok().messages.filter((message) => message.role === "system" || isAppContextMessage(message)));
-                if (acquired.isErr())
-                    return Result.Err(acquired.Err());
-                const { live, created } = acquired.Ok();
-                const composedHead = rAgent.Ok().headFsId;
-                if (composedHead !== undefined) {
-                    const noted = await live.session.observeHead(composedHead);
-                    if (noted.isErr())
-                        vctx.logger.Warn().Err(noted).Str("chatId", req.chatId).Msg("agent-session-head-note-failed");
-                }
-                if (created === false) {
-                    const receiptId = vctx.sthis.nextId(12).str;
-                    const receiptEvidence = createAgentEvidenceWriter({
-                        chatId: req.chatId,
-                        promptId: receiptId,
-                        sessionId: live.promptId,
-                        append: (evt, blockSeq) => appendBlockEvent({ ctx, vctx, req, promptId: receiptId, blockSeq, evt }),
-                    });
-                    const linked = await receiptEvidence({ kind: "active" });
-                    if (linked.isErr())
-                        return Result.Err(linked.Err());
-                    await ctx.send.send(ctx, wrapMsgBase(ctx.validated, {
-                        payload: {
-                            type: "vibes.diy.res-prompt-chat-section",
-                            chatId: req.chatId,
-                            ownerHandle: resChat.ownerHandle,
-                            appSlug: resChat.appSlug,
-                            promptId: receiptId,
-                            outerTid: req.outerTid,
-                            mode: req.mode,
-                        },
-                        tid: ctx.validated.tid,
-                        src: "agentSession",
-                    }));
-                    const echo = await appendBlockEvent({
-                        ctx,
-                        vctx,
-                        req,
-                        promptId: receiptId,
-                        blockSeq: 0,
-                        evt: {
-                            type: "prompt.req",
-                            ...(orig.mode === "codegen" && orig.source === "suggestion" ? { source: "suggestion" } : {}),
-                            streamId: receiptId,
-                            chatId: req.chatId,
-                            seq: 0,
-                            request: { messages: rawIncoming },
-                            timestamp: new Date(),
-                        },
-                    });
-                    if (echo.isErr())
-                        return Result.Err(echo.Err());
-                    const terminal = await appendBlockEvent({
-                        ctx,
-                        vctx,
-                        req,
-                        promptId: receiptId,
-                        blockSeq: 1,
-                        evt: {
-                            type: "block.end",
-                            streamId: receiptId,
-                            blockId: receiptId,
-                            blockNr: 0,
-                            seq: 1,
-                            timestamp: new Date(),
-                            stats: {
-                                toplevel: { lines: 0, bytes: 0 },
-                                code: { lines: 0, bytes: 0 },
-                                image: { lines: 0, bytes: 0 },
-                                total: { lines: 0, bytes: 0 },
-                            },
-                            usage: { given: [], calculated: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } },
-                        },
-                    });
-                    if (terminal.isErr())
-                        return Result.Err(terminal.Err());
-                    const ended = await appendBlockEvent({
-                        ctx,
-                        vctx,
-                        req,
-                        promptId: receiptId,
-                        blockSeq: 2,
-                        evt: { type: "prompt.block-end", streamId: receiptId, chatId: req.chatId, seq: 2, timestamp: new Date() },
-                    });
-                    if (ended.isErr())
-                        return Result.Err(ended.Err());
+                const agent = rAgent.Ok();
+                if (agent.kind === "receipt")
                     return Result.Ok(EventoResult.Continue);
-                }
-                agentSession = live;
-                agentEvidence = observeEvidenceLine(createAgentEvidenceWriter({
-                    chatId: req.chatId,
-                    promptId: live.promptId,
-                    sessionId: live.promptId,
-                    append: (evt, blockSeq) => appendBlockEvent({ ctx, vctx, req, promptId: live.promptId, blockSeq, evt }),
-                }), turnLatency);
-                const active = await agentEvidence({
-                    kind: "active",
-                    ...(live.supersedes === undefined ? {} : { supersedes: live.supersedes }),
-                });
-                if (active.isErr()) {
-                    live.close();
-                    return Result.Err(active.Err());
-                }
-                if (live.session.messages().length === 0) {
-                    const initial = agentAssembled.messages.slice(0, agentAssembled.messages.length - newMessageCount - (agentWakeNote === undefined ? 0 : 1));
-                    const saved = await live.session.checkpoint(initial);
-                    if (saved.isErr()) {
-                        live.close();
-                        return Result.Err(saved.Err());
-                    }
-                }
-                const events = await nextAgentSessionMessages(live.session, agentEvidence);
-                if (events.isErr()) {
-                    live.close();
-                    return Result.Err(events.Err());
-                }
-                agentAssembled = {
-                    ...agentAssembled,
-                    messages: composeAgentRequest({
-                        system: agentAssembled.messages.filter((message) => message.role === "system"),
-                        journal: markJournalCacheTail(live.session.messages()),
-                        context: agentAssembled.messages.filter(isAppContextMessage),
-                        tail: events.Ok() ?? [],
-                    }),
-                };
-                const saved = await live.session.checkpoint(agentAssembled.messages);
-                if (saved.isErr()) {
-                    live.close();
-                    return Result.Err(saved.Err());
-                }
+                agentAssembled = agent.agentAssembled;
+                agentSession = agent.agentSession;
+                agentEvidence = agent.agentEvidence;
+                agentFetchUrlContext = agent.agentFetchUrlContext;
             }
             else {
-                const rAssembled = await assemblePromptPayload(vctx, {
-                    chatId: req.chatId,
-                    userId: req._auth.verifiedAuth.claims.userId,
-                    model: modelId,
-                    newUserMessages: orig.prompt.messages.filter(isChatMessage),
-                    selected: orig.selected,
-                    slots: resolveSlotConfig(orig.slots, {
-                        SLOTS_ORIGINAL: vctx.sthis.env.get("SLOTS_ORIGINAL"),
-                        SLOTS_SELECTED: vctx.sthis.env.get("SLOTS_SELECTED"),
-                        SLOTS_LAST_EDIT: vctx.sthis.env.get("SLOTS_LAST_EDIT"),
-                        SLOTS_PREVIOUS: vctx.sthis.env.get("SLOTS_PREVIOUS"),
-                        SLOTS_COMPACTION: vctx.sthis.env.get("SLOTS_COMPACTION"),
-                    }),
-                    focusPath: orig.focusPath,
-                    attachScreenshot: orig.dryRun !== true,
-                    degradeAttachments: orig.dryRun === true,
-                    ...(directBuildRequested && Array.isArray(orig.agentSkills) && orig.agentSkills.length > 0
-                        ? { forceSkills: orig.agentSkills }
-                        : {}),
-                });
-                if (rAssembled.isErr())
-                    return Result.Err(rAssembled);
-                preAssembled = rAssembled.Ok();
-                if (orig.dryRun === true) {
-                    const dryRunPromptId = `dry-run-${vctx.sthis.nextId(12).str}`;
-                    await ctx.send.send(ctx, wrapMsgBase(ctx.validated, {
-                        payload: {
-                            type: "vibes.diy.res-prompt-chat-section",
-                            chatId: req.chatId,
-                            ownerHandle: resChat.ownerHandle,
-                            appSlug: resChat.appSlug,
-                            promptId: dryRunPromptId,
-                            outerTid: req.outerTid,
-                            mode: req.mode,
-                        },
-                        tid: ctx.validated.tid,
-                        src: "promptChatSection",
-                    }));
-                    const now = () => new Date();
-                    let seq = 0;
-                    await appendBlockEvent({
-                        ctx,
-                        vctx,
-                        req,
-                        promptId: dryRunPromptId,
-                        blockSeq: seq,
-                        emitMode: "emit-only",
-                        evt: { type: "prompt.block-begin", streamId: dryRunPromptId, chatId: req.chatId, seq, timestamp: now() },
-                    });
-                    seq++;
-                    await appendBlockEvent({
-                        ctx,
-                        vctx,
-                        req,
-                        promptId: dryRunPromptId,
-                        blockSeq: seq,
-                        emitMode: "emit-only",
-                        evt: {
-                            type: "prompt.dry-run-payload",
-                            streamId: dryRunPromptId,
-                            chatId: req.chatId,
-                            seq,
-                            timestamp: now(),
-                            request: { ...orig.prompt, model: preAssembled.model, messages: preAssembled.messages },
-                        },
-                    });
-                    seq++;
-                    await appendBlockEvent({
-                        ctx,
-                        vctx,
-                        req,
-                        promptId: dryRunPromptId,
-                        blockSeq: seq,
-                        emitMode: "emit-only",
-                        evt: { type: "prompt.block-end", streamId: dryRunPromptId, chatId: req.chatId, seq, timestamp: now() },
-                    });
-                    return Result.Ok(EventoResult.Continue);
-                }
-            }
-        }
-        let resolvedImgModel;
-        if (isReqPromptImageChatSection(orig)) {
-            const override = orig.prompt.model;
-            if (override) {
-                resolvedImgModel = override;
-            }
-            else {
-                const rDefaults = await getModelDefaults(vctx, { appSlug: resChat.appSlug, ownerHandle: resChat.ownerHandle });
-                if (rDefaults.isOk()) {
-                    const defaults = rDefaults.Ok();
-                    const hasInputImage = !!orig.inputImageBase64;
-                    const editDefault = hasInputImage ? defaults["img-edit"] : undefined;
-                    resolvedImgModel = (editDefault ?? defaults.img).model.id;
-                    orig.prompt.model = resolvedImgModel;
-                }
-            }
-        }
-        if (resolvedImgModel?.startsWith("prodia/") && !vctx.prodiaToken) {
-            resolvedImgModel = "google/gemini-2.5-flash-image";
-            if (isReqPromptImageChatSection(orig)) {
-                orig.prompt.model = resolvedImgModel;
-            }
-        }
-        const useProdia = !!(isReqPromptImageChatSection(orig) && vctx.prodiaToken && resolvedImgModel?.startsWith("prodia/"));
-        const terminal = { promptBlockEndEmitted: false, latency: turnLatency };
-        let prompSectionAction;
-        if (isReqPromptImageChatSection(orig) && useProdia) {
-            prompSectionAction = async (scope, blockSeq) => {
-                const reqWithAuth = { ...orig, _auth: req._auth };
-                return handleProdiaImageRequest({
-                    scope,
-                    ctx,
-                    vctx,
-                    req: reqWithAuth,
-                    promptId,
-                    blockSeq,
-                    resolvedModel: resolvedImgModel,
-                    resChat,
-                });
-            };
-        }
-        else if (agentAssembled !== undefined && isReqPromptLLMChatSection(orig)) {
-            const agentPayload = agentAssembled;
-            const liveSession = agentSession;
-            if (liveSession === undefined)
-                return Result.Err("Agent turn has no session");
-            prompSectionAction = async (scope, blockSeq) => {
-                const rActor = await resolveAgentActor(vctx, {
-                    userId: req._auth.verifiedAuth.claims.userId,
-                    scope: agentFirstTurnMint
-                        ? { ownerHandle: resChat.ownerHandle }
-                        : { ownerHandle: resChat.ownerHandle, appSlug: resChat.appSlug },
-                });
-                if (rActor.isErr())
-                    return Result.Err(rActor.Err());
-                let liveAppSlug = resChat.appSlug;
-                let firstTurnAppClaimed = agentFirstTurnMint === false;
-                const rVfs = await loadWorkVfs(vctx, {
-                    chatId: req.chatId,
-                    ownerHandle: resChat.ownerHandle,
-                    appSlug: resChat.appSlug,
-                    editBaseFsId: undefined,
-                });
-                if (rVfs.isErr())
-                    return Result.Err(rVfs.Err());
-                const vfs = new Map(rVfs.Ok());
-                function extendDeadlineForAwaitedBuild(awaiting) {
-                    void extendOpenTurnDeadline(vctx.sql, {
-                        chatId: req.chatId,
-                        promptId,
-                        deadlineAtMs: Date.now() + OPEN_TURN_AWAIT_BUILD_EXTENSION_MS,
-                    }).then((r) => {
-                        if (r.isErr()) {
-                            vctx.logger
-                                .Warn()
-                                .Err(r)
-                                .Any("event", { chatId: req.chatId, promptId, awaiting })
-                                .Msg("agent-await-deadline-extend-failed");
-                        }
-                    });
-                }
-                const firstTurnFileBlocks = orig.prompt.messages
-                    .filter(isUserChatMessage)
-                    .flatMap((m) => m.content.filter((c) => c.type === "vibes_file"));
-                const dispatcher = createAgentBuildDispatcher({
-                    vctx,
-                    host: ctx,
-                    auth: req.auth,
-                    outerTid: req.outerTid,
-                    handle: (dispatchCtx) => promptChatSection.handle(dispatchCtx),
-                    wakeBudget: 0,
-                    onPendingBuild: (t) => {
-                        extendDeadlineForAwaitedBuild(t.promptId);
-                        return liveSession.watch(t.promptId);
-                    },
-                    ...(agentFirstTurnMint
-                        ? {
-                            firstTurn: {
-                                chatId: req.chatId,
-                                ...(submittedAt === undefined ? {} : { submittedAt }),
-                                ...(firstTurnFileBlocks.length === 0 ? {} : { fileBlocks: firstTurnFileBlocks }),
-                                ...(orig.varietyPin === undefined
-                                    ? {}
-                                    : { varietyPin: orig.varietyPin }),
-                                ...(typeof orig.stylePin === "string"
-                                    ? { stylePin: orig.stylePin }
-                                    : {}),
-                            },
-                        }
-                        : {}),
-                    ...(Object.keys(dispatchCarry).length === 0 ? {} : { carry: dispatchCarry }),
-                });
-                const belt = createAgentBelt(vctx, {
-                    actor: rActor.Ok(),
-                    chatId: req.chatId,
-                    vfs,
-                    ...(agentFirstTurnMint
-                        ? {
-                            firstTurn: {
-                                chatId: req.chatId,
-                                claim: () => claimFirstTurnMint(vctx, req.chatId),
-                                release: async () => {
-                                    await claimMintJob(vctx, req.chatId, ["pending"], "agent");
-                                },
-                            },
-                        }
-                        : {}),
-                    ...(agentFetchUrlContext === undefined ? {} : { fetchUrl: agentFetchUrlContext }),
-                    dispatcher,
-                    queueEdit: (input) => liveSession.queue(input),
-                    fileSession: liveSession,
-                    ...(instructionVariant === undefined ? {} : { instructionVariant }),
-                    onStyleApplied: async (applied) => {
-                        await appendBlockEvent({
-                            ctx,
-                            vctx,
-                            req,
-                            promptId,
-                            blockSeq,
-                            evt: {
-                                type: "prompt.restyle",
-                                streamId: promptId,
-                                chatId: req.chatId,
-                                seq: blockSeq,
-                                timestamp: new Date(),
-                                style: applied.style,
-                                description: applied.description,
-                            },
-                            emitMode: "emit-only",
-                        });
-                    },
-                    onDispatch: (dispatched) => {
-                        liveAppSlug = dispatched.appSlug;
-                        liveSession.claimAppAddress(dispatched.appSlug);
-                        firstTurnAppClaimed = true;
-                        vctx.logger
-                            .Info()
-                            .Any("event", { chatId: dispatched.chatId, appSlug: dispatched.appSlug, promptId })
-                            .Msg("agent-turn-dispatched-build");
-                    },
-                });
-                turnToolsOffered = belt.definitions.map((d) => d.function.name);
-                await liveSession.bind((input) => runEditVibeTool(vctx, {
-                    actor: rActor.Ok(),
-                    chatId: req.chatId,
-                    input,
-                    dispatcher,
-                    toolsOffered: belt.definitions.map((d) => d.function.name),
-                }), async (commit) => {
-                    if (firstTurnAppClaimed === false)
-                        return Result.Ok({
-                            ok: false,
-                            reason: "no-app-yet",
-                            message: "Call create_vibe first; there is no app to edit until it has been created.",
-                        });
-                    const currentActor = await resolveAgentActor(vctx, {
-                        userId: rActor.Ok().userId,
-                        requestedHandle: rActor.Ok().ownerHandle,
-                        scope: rActor.Ok().scope,
-                    });
-                    if (currentActor.isErr())
-                        return Result.Err(currentActor.Err());
-                    const scoped = await resolveChatApp(vctx, currentActor.Ok(), req.chatId);
-                    if (scoped.isErr())
-                        return Result.Err(scoped.Err());
-                    const commitId = vctx.sthis.nextId(12).str;
-                    const lock = acquireTurnBuildLock({
-                        vctx,
-                        chatId: req.chatId,
-                        promptId: commitId,
-                        movesFilesystem: true,
-                        wakesOnTerminal: false,
-                    });
-                    if (lock.acquired === false)
-                        return Result.Err("A build is running; the staged commit could not acquire the write lane.");
-                    const committed = { promptBlockEndEmitted: false };
-                    const saved = await exception2Result(() => handleFSPrompt({
-                        scope,
-                        vctx,
-                        ctx,
-                        promptId: commitId,
-                        blockSeq: 0,
-                        terminal: committed,
-                        beginDirect: true,
-                        resChat: { ...resChat, mode: "fs-update" },
-                        req: {
-                            type: "vibes.diy.req-prompt-chat-section",
-                            mode: "fs-update",
-                            auth: req.auth,
-                            _auth: req._auth,
-                            chatId: req.chatId,
-                            outerTid: req.outerTid,
-                            agentFileCommit: commit,
-                            fsUpdate: {
-                                update: commit.changes.map((file) => ({
-                                    type: "code-block",
-                                    filename: file.path,
-                                    content: file.contents,
-                                    lang: langForFilename(file.path),
-                                })),
-                                remove: [],
-                            },
-                        },
-                    })).finally(() => {
-                        committed.releasePersistGate?.();
-                        releaseTurnBuildLock(vctx, req.chatId, commitId);
-                    });
-                    if (saved.isErr()) {
-                        const last = await maxPersistedBlockSeq(vctx.sql, { chatId: req.chatId, promptId: commitId });
-                        if (last.isErr())
-                            return Result.Err(last.Err());
-                        const seq = (last.Ok() ?? -1) + 1;
-                        await appendBlockEvent({
-                            ctx,
-                            vctx,
-                            req,
-                            promptId: commitId,
-                            blockSeq: seq,
-                            evt: {
-                                type: "prompt.error",
-                                streamId: commitId,
-                                chatId: req.chatId,
-                                seq,
-                                timestamp: new Date(),
-                                error: saved.Err().message,
-                            },
-                        });
-                        return Result.Err(saved.Err());
-                    }
-                    if (committed.fsRef === undefined)
-                        return Result.Err("The commit did not persist a version.");
-                    const committedPaths = commit.changes.map((file) => file.path);
-                    return Result.Ok({
-                        ok: true,
-                        saved: true,
-                        fsRef: committed.fsRef,
-                        paths: committedPaths,
-                        entryTouched: classifyTurnReach(committedPaths).entryTouched,
-                    });
-                });
-                const res = await handlerLlmRequest({
+                const rCodegen = await assembleCodegenTurn({
                     ctx,
-                    blockSeq,
-                    scope,
-                    vctx,
-                    req: req,
-                    resChat,
-                    promptId,
-                    preAssembled: { ...agentPayload, isInitialTurn: false },
-                    modelUsage: "agent",
-                    serverTools: belt.definitions,
-                });
-                const evidence = agentEvidence ??
-                    observeEvidenceLine(createAgentEvidenceWriter({
-                        chatId: req.chatId,
-                        promptId,
-                        sessionId: liveSession.promptId,
-                        append: (evt, blockSeq) => appendBlockEvent({ ctx, vctx, req, promptId, blockSeq, evt }),
-                    }), turnLatency);
-                let providerStream;
-                const rSse = createProviderSseStream(res.res, promptId);
-                if (rSse.isErr()) {
-                    vctx.logger.Warn().Err(rSse).Str("chatId", req.chatId).Msg("agent-turn-provider-stream-unavailable");
-                }
-                else {
-                    providerStream = createAgentTurnStream({
-                        vctx,
-                        belt,
-                        actor: rActor.Ok(),
-                        chatId: req.chatId,
-                        vfs,
-                        dispatcher,
-                        request: res.llmReq,
-                        stream: rSse.Ok(),
-                        abort: res.abort,
-                        onToolEvidence: ({ kind, call, text, round, epoch }) => evidence({ kind, callId: call.id, name: call.name, text, round, epoch }),
-                        session: {
-                            checkpoint: async (messages) => {
-                                const saved = await liveSession.session.checkpoint(messages);
-                                if (saved.isErr())
-                                    return saved;
-                                const extended = await extendOpenTurnDeadline(vctx.sql, {
-                                    chatId: req.chatId,
-                                    promptId,
-                                    deadlineAtMs: Date.now() + agentTotalBudgetMs(vctx) + OPEN_TURN_AWAIT_BUILD_EXTENSION_MS,
-                                });
-                                if (extended.isErr())
-                                    return Result.Err(extended.Err());
-                                return Result.Ok();
-                            },
-                            next: () => nextAgentSessionMessages(liveSession.session, evidence),
-                            head: () => liveSession.session.head(),
-                            dispatchBudgetMs: agentTotalBudgetMs(vctx),
-                        },
-                        dispatch: async ({ request, budget }) => {
-                            const messages = agentFirstTurnMint && firstTurnAppClaimed
-                                ? claimAgentAppContext(request.messages, { ownerHandle: resChat.ownerHandle, appSlug: liveAppSlug })
-                                : request.messages;
-                            {
-                                const latest = await loadWorkVfs(vctx, {
-                                    chatId: req.chatId,
-                                    ownerHandle: resChat.ownerHandle,
-                                    appSlug: liveAppSlug,
-                                    editBaseFsId: undefined,
-                                });
-                                if (latest.isErr())
-                                    return Result.Err(latest.Err());
-                                vfs.clear();
-                                for (const [path, content] of latest.Ok())
-                                    vfs.set(path, content);
-                            }
-                            const dispatch = await dispatchLlmRequestWithFallback({
-                                vctx,
-                                mode: req.mode,
-                                llmReq: { ...res.llmReq, messages },
-                                chatId: req.chatId,
-                                promptId,
-                                phase: "tool-resume",
-                                budget,
-                            });
-                            if (dispatch.ok === false)
-                                return Result.Err(dispatch.error);
-                            const rRound = createProviderSseStream(dispatch.res, promptId);
-                            if (rRound.isErr())
-                                return Result.Err(rRound);
-                            return Result.Ok({
-                                request: { ...res.llmReq, messages },
-                                stream: rRound.Ok(),
-                                abort: dispatch.abort,
-                            });
-                        },
-                        onError: (error) => {
-                            vctx.logger.Warn().Any("event", { chatId: req.chatId, promptId, error }).Msg("agent-turn-loop-failed");
-                        },
-                    });
-                }
-                const finalBlockSeq = await handleLlmResponse({
-                    scope,
                     vctx,
-                    req: req,
-                    ctx,
-                    res: res.res,
-                    resChat,
-                    promptId,
-                    blockSeq: res.blockSeq,
-                    llmReq: res.llmReq,
-                    abort: res.abort,
-                    ...(providerStream === undefined ? {} : { providerStream }),
-                    stripServerTools: withoutServerTools,
-                    proseOnly: true,
-                    terminal,
-                    researchRequested: false,
-                    platformInitiated: agentWakeTurn,
-                    step: agentWakeTurn ? "wake" : "agent",
-                });
-                return Result.Ok(finalBlockSeq);
-            };
-        }
-        else if (isReqPromptLLMChatSection(orig)) {
-            const buildStep = promptStepFor({
-                agentTurn: false,
-                agentWake: false,
-                agentDispatched: agentDispatchedBuild,
-                agentStep: orig.agentStep,
-                agentSkills: orig.agentSkills,
-            });
-            prompSectionAction = async (scope, blockSeq) => {
-                const res = await handlerLlmRequest({
-                    ctx,
-                    blockSeq,
-                    scope,
-                    vctx,
-                    req: req,
-                    resChat,
-                    promptId,
-                    preAssembled,
-                    ...(agentDispatchedBuild ? { initiator: "platform" } : {}),
-                    ...(agentDispatchedBuild ? { agentDispatched: true } : {}),
-                });
-                if (res.urlResearchJob !== undefined) {
-                    scheduleUrlResearch((message) => exception2Result(() => Result.Ok(vctx.postQueue(message))), res.urlResearchJob, {
-                        waitUntil: vctx.waitUntil,
-                        onError: (error) => {
-                            vctx.logger
-                                .Warn()
-                                .Any("event", { chatId: req.chatId, promptId, error: String(error) })
-                                .Msg("url-research-enqueue-failed");
-                        },
-                    });
-                }
-                const finalBlockSeq = await handleLlmResponse({
-                    scope,
-                    vctx,
-                    req: req,
-                    ctx,
-                    res: res.res,
-                    resChat,
-                    promptId,
-                    blockSeq: res.blockSeq,
-                    llmReq: res.llmReq,
-                    abort: res.abort,
-                    terminal,
-                    researchRequested: res.urlResearchJob !== undefined,
-                    frontendDraft: preAssembled?.frontendDraft === true && req.mode === "codegen",
-                    codegenTheme: preAssembled?.codegenTheme,
-                    codegenVariety: preAssembled?.codegenVariety,
-                    editBaseFsId: preAssembled?.editBaseFsId,
-                    agentDispatched: agentDispatchedBuild,
-                    ...(buildStep === undefined ? {} : { step: buildStep }),
-                    ...(res.urlResearchJob === undefined ? {} : { researchModel: res.urlResearchJob.model }),
-                });
-                return Result.Ok(finalBlockSeq);
-            };
-        }
-        if (isReqPromptFSChatSection(orig)) {
-            prompSectionAction = async (scope, blockSeq) => {
-                const r = await handleFSPrompt({
-                    scope,
-                    vctx,
-                    req: req,
-                    ctx,
+                    req,
+                    orig,
                     resChat,
-                    promptId,
-                    blockSeq,
-                    terminal,
+                    modelId: route.modelId,
+                    directBuildRequested: envelope.directBuildRequested,
                 });
-                return r;
-            };
-        }
-        if (!prompSectionAction) {
-            return Result.Err(`Unsupported prompt chat section mode: ${orig.mode}`);
+                if (rCodegen.isErr())
+                    return Result.Err(rCodegen);
+                const codegen = rCodegen.Ok();
+                if (codegen.kind === "dry-run-done")
+                    return Result.Ok(EventoResult.Continue);
+                preAssembled = codegen.preAssembled;
+            }
         }
+        const { resolvedImgModel, useProdia } = await resolveImageModel(vctx, orig, resChat);
+        const terminal = { promptBlockEndEmitted: false, latency: turnLatency };
+        const reenter = (reentry) => promptChatSection.handle(reentry);
+        const rSectionAction = selectPromptSectionAction({
+            ctx,
+            vctx,
+            req,
+            orig,
+            resChat,
+            resolvedImgModel,
+            useProdia,
+            preAssembled,
+            agentAssembled,
+            agentSession,
+            agentEvidence,
+            agentFetchUrlContext,
+            agentFirstTurnMint,
+            envelope,
+            dispatchCarry,
+            instructionVariant,
+            subagentModel,
+            subagentCall,
+            turnLatency,
+            terminal,
+            facts,
+            reenter,
+        });
+        if (rSectionAction.isErr())
+            return Result.Err(rSectionAction);
+        const prompSectionAction = rSectionAction.Ok();
         const rBump = await bumpAppRecency(vctx, { ownerHandle: resChat.ownerHandle, appSlug: resChat.appSlug });
         if (rBump.isErr()) {
             vctx.logger.Warn().Err(rBump).Msg("bumpAppRecency failed");
@@ -1006,64 +196,8 @@ const accountPromptChatSection = {
         await scopey(async (scope) => {
             const seq = { val: 0 };
             const notifiesBuild = isBuildNotifyMode(req.mode);
-            let turnErrored = false;
-            let turnErrorReason;
-            scope.onCatch(async (e) => {
-                turnErrored = true;
-                const failureMessage = e.message;
-                if (failureMessage !== "")
-                    turnErrorReason = failureMessage;
-                const rMaxSeq = await maxPersistedBlockSeq(vctx.sql, { chatId: req.chatId, promptId });
-                const maxSeq = rMaxSeq.isOk() ? rMaxSeq.Ok() : undefined;
-                if (maxSeq !== undefined) {
-                    seq.val = Math.max(seq.val, maxSeq + 1);
-                }
-                const errorSeq = seq.val;
-                seq.val++;
-                const rError = await appendBlockEvent({
-                    ctx,
-                    vctx,
-                    req,
-                    promptId,
-                    blockSeq: errorSeq,
-                    evt: {
-                        type: "prompt.error",
-                        streamId: promptId,
-                        chatId: req.chatId,
-                        seq: errorSeq,
-                        timestamp: new Date(),
-                        error: e.message,
-                    },
-                });
-                if (rError.isErr()) {
-                    vctx.logger
-                        .Error()
-                        .Err(rError)
-                        .Any("event", { chatId: req.chatId, promptId, blockSeq: errorSeq })
-                        .Msg("prompt-error-persist-failed");
-                }
-                if (vctx.notifyUser && notifiesBuild) {
-                    const userId = req._auth.verifiedAuth.claims.userId;
-                    const connId = clientWsSend(ctx).connId;
-                    const prefs = await loadNotificationPrefs(vctx, userId);
-                    if (shouldNotify(prefs, {
-                        notificationType: "build-failed",
-                        ownerHandle: resChat.ownerHandle,
-                        appSlug: resChat.appSlug,
-                    })) {
-                        void vctx
-                            .notifyUser(userId, {
-                            type: "vibes.diy.evt-user-notification",
-                            notificationType: "build-failed",
-                            ownerHandle: resChat.ownerHandle,
-                            appSlug: resChat.appSlug,
-                            promptId,
-                        }, connId)
-                            .catch((_e) => {
-                        });
-                    }
-                }
-            }, 0);
+            const terminalArgs = { ctx, vctx, req, resChat, promptId, seq, facts, notifiesBuild };
+            scope.onCatch(async (e) => recordTurnError(terminalArgs, e), 0);
             await scope
                 .evalResult(async () => {
                 const res = await appendBlockEvent({
@@ -1081,7 +215,7 @@ const accountPromptChatSection = {
                     },
                 });
                 seq.val++;
-                const rAction = await prompSectionAction(scope, seq.val);
+                const rAction = await prompSectionAction({ scope, blockSeq: seq.val, promptId });
                 if (rAction.isErr())
                     return rAction;
                 seq.val = rAction.Ok();
@@ -1089,218 +223,36 @@ const accountPromptChatSection = {
             })
                 .finally(async () => {
                 const turnBegan = seq.val > 0;
-                let settledArgs;
-                let lookLintPlan;
                 try {
-                    await finalizePromptTurn();
+                    await finalizePromptTurn({ ...terminalArgs, terminal });
                 }
                 finally {
-                    if (turnBegan && canonicalModelUsage(req.mode) === "codegen") {
-                        lookLintPlan = {
-                            theme: preAssembled?.codegenTheme,
-                            committed: terminal.fsRef !== undefined,
-                        };
-                        const turnOrigin = submittedAt ?? turnStartedAt;
-                        const msToFirstToken = msSinceOrigin(turnOrigin, turnLatency.firstTokenAt);
-                        const msToFirstEvidence = msSinceOrigin(turnOrigin, turnLatency.firstEvidenceLineAt);
-                        settledArgs = {
-                            outcome: turnErrored ? "error" : terminal.settled?.applied === true ? "applied" : "no-code",
-                            userId: req._auth.verifiedAuth.claims.userId,
-                            ownerHandle: resChat.ownerHandle,
-                            appSlug: resChat.appSlug,
-                            reach: projectTurnReach(terminal.settled, terminal.touchedPaths),
-                            lane: codegenTurnLane({ agentAssembled: agentAssembled !== undefined, agentDispatched: agentDispatchedBuild }),
-                            firstBuild: preAssembled?.isInitialTurn === true,
-                            msFromSubmit: Math.max(0, Date.now() - turnOrigin),
-                            ...(msToFirstToken === undefined ? {} : { msToFirstToken }),
-                            ...(msToFirstEvidence === undefined ? {} : { msToFirstEvidence }),
-                            toolsOffered: turnToolsOffered,
-                            skills: preAssembled?.skills ?? [],
-                            ...(terminal.recovery === undefined ? {} : { recovery: terminal.recovery }),
-                        };
-                        if (lookLintPlanned(lookLintPlan) === false)
-                            captureCodegenTurnSettled(vctx, settledArgs);
-                        postMakerFact(vctx, {
-                            eventId: `turn:${promptId}`,
-                            userId: req._auth.verifiedAuth.claims.userId,
-                            at: new Date().toISOString(),
-                            kind: "codegen-turn",
-                        }, "codegen-turn-settled");
-                        const ownWords = agentDispatchedBuild === false && agentWakeTurn === false && isReqPromptLLMChatSection(orig)
-                            ? currentUserMessageText(orig.prompt.messages.filter(isChatMessage))
-                            : undefined;
-                        postCapiBuildEvent(vctx, {
-                            outcome: settledArgs.outcome,
-                            firstBuild: settledArgs.firstBuild,
-                            promptId,
-                            userId: req._auth.verifiedAuth.claims.userId,
-                            promptText: ownWords,
-                        });
-                    }
-                    peekInFlightTurns(req.chatId)?.delete(promptId);
-                    await agentSession?.settle();
-                    releaseTurnBuildLock(vctx, req.chatId, promptId);
-                    terminal.releasePersistGate?.();
-                    if (settledArgs !== undefined && lookLintPlan !== undefined) {
-                        const args = settledArgs;
-                        dispatchLookLint(vctx, {
-                            ...lookLintPlan,
-                            files: async () => (terminal.fsRef === undefined ? {} : loadTurnFilesByFsId(vctx, terminal.fsRef.fsId)),
-                            onResult: (lookLint) => {
-                                captureCodegenTurnSettled(vctx, lookLint === undefined ? args : { ...args, lookLint });
-                            },
-                        });
-                    }
-                    const accessTouched = (terminal.touchedPaths ?? []).some((path) => /\/?(access\.js|seed\.json)$/.test(path)) &&
-                        terminal.fsRef !== undefined;
-                    const accessFsRef = terminal.fsRef;
-                    const rAccessReport = await exception2Result(async () => {
-                        if (!accessTouched || accessFsRef === undefined)
-                            return undefined;
-                        const report = await releaseAccessVerdicts(vctx, {
-                            ownerHandle: resChat.ownerHandle,
-                            appSlug: resChat.appSlug,
-                            files: () => loadTurnFilesByFsId(vctx, accessFsRef.fsId),
-                        });
-                        if (report !== undefined) {
-                            captureAccessVerdicts(vctx, {
-                                lane: "build",
-                                userId: req._auth.verifiedAuth.claims.userId,
-                                ownerHandle: resChat.ownerHandle,
-                                appSlug: resChat.appSlug,
-                                report,
-                                accessChanged: (terminal.touchedPaths ?? []).some((path) => /\/?access\.js$/.test(path)),
-                            });
-                        }
-                        return report;
-                    });
-                    if (rAccessReport.isErr()) {
-                        vctx.logger.Warn().Err(rAccessReport.Err()).Str("promptId", promptId).Msg("access-verdicts-terminal-failed");
-                    }
-                    const accessReport = rAccessReport.isErr() ? undefined : rAccessReport.Ok();
-                    const landingOutcome = {
-                        outcome: turnErrored
-                            ? "error"
-                            : terminal.settled?.applied === true
-                                ? "applied"
-                                : "no-code",
-                        ...(terminal.touchedPaths === undefined ? {} : { touchedPaths: terminal.touchedPaths }),
-                        ...(terminal.settled === undefined || turnErrored ? {} : { settled: terminal.settled }),
-                        ...(terminal.fsRef === undefined ? {} : { fsId: terminal.fsRef.fsId }),
-                        ...(accessReport === undefined ? {} : { accessLine: renderAccessVerdictLine(accessReport) }),
-                        ...(turnErrorReason === undefined ? {} : { errorReason: turnErrorReason }),
-                    };
-                    const { consumed } = settleTurnTerminal(vctx.connections, req.chatId, promptId, landingOutcome);
-                    const wake = decideAgentWake({
-                        agentDispatched: agentDispatchedBuild,
-                        movedFilesystem: movesFilesystem,
-                        budget: 1,
+                    await settlePromptTurn({
+                        ctx,
+                        vctx,
+                        req,
+                        orig,
+                        resChat,
+                        promptId,
+                        terminal,
+                        facts,
+                        turnBegan,
+                        preAssembled,
+                        agentAssembled,
+                        agentSession,
+                        envelope,
+                        turnStartedAt,
+                        turnLatency,
+                        movesFilesystem,
+                        builderModel,
+                        subagentModel,
+                        instructionVariant,
+                        wakeAgentModel,
+                        reenter,
                     });
-                    if (consumed === true) {
-                        vctx.logger
-                            .Info()
-                            .Any("event", { chatId: req.chatId, promptId, outcome: landingOutcome.outcome })
-                            .Msg("agent-build-landing-consumed");
-                    }
-                    else if (wake.wake === true) {
-                        vctx.logger.Info().Any("event", { chatId: req.chatId, promptId, budget: wake.budget }).Msg("agent-wake-firing");
-                        fireAgentWakeTurn({
-                            vctx,
-                            host: ctx,
-                            auth: req.auth,
-                            outerTid: req.outerTid,
-                            chatId: req.chatId,
-                            budget: wake.budget,
-                            note: renderAgentWakeNote(landingOutcome),
-                            ...(builderModel === undefined ? {} : { builderModel }),
-                            ...(instructionVariant === undefined ? {} : { instructionVariant }),
-                            ...(wakeAgentModel === undefined ? {} : { agentModel: wakeAgentModel }),
-                            handle: (wakeCtx) => promptChatSection.handle(promptDispatchContext(ctx, wakeCtx.validated)),
-                        });
-                    }
-                    else {
-                        vctx.logger
-                            .Info()
-                            .Any("event", {
-                            chatId: req.chatId,
-                            promptId,
-                            skip: wake.skip,
-                            agentDispatched: agentDispatchedBuild,
-                            movedFilesystem: movesFilesystem,
-                            budget: agentWakeBudget,
-                        })
-                            .Msg("agent-wake-skipped");
-                    }
                 }
             })
                 .do();
-            async function finalizePromptTurn() {
-                if (seq.val === 0)
-                    return;
-                const rEnd = await appendBlockEvent({
-                    ctx,
-                    vctx,
-                    req,
-                    promptId,
-                    blockSeq: seq.val,
-                    evt: {
-                        type: "prompt.block-end",
-                        streamId: promptId,
-                        chatId: req.chatId,
-                        seq: seq.val,
-                        timestamp: new Date(),
-                    },
-                    emitMode: terminal.promptBlockEndEmitted ? "store-only" : "store",
-                });
-                if (rEnd.isErr()) {
-                    vctx.logger
-                        .Error()
-                        .Err(rEnd)
-                        .Any("event", { chatId: req.chatId, promptId, blockSeq: seq.val })
-                        .Msg("prompt-block-end-persist-failed");
-                }
-                if (shouldCloseTurnRecord({ canonicalMode: canonicalModelUsage(req.mode), terminalPersisted: rEnd.isOk() })) {
-                    const rClose = await closeTurn(vctx.sql, { chatId: req.chatId, promptId });
-                    if (rClose.isErr()) {
-                        vctx.logger.Warn().Err(rClose).Any("event", { chatId: req.chatId, promptId }).Msg("close-turn-record-failed");
-                    }
-                    else if (rClose.Ok() === false) {
-                        vctx.logger.Warn().Any("event", { chatId: req.chatId, promptId, turnErrored }).Msg("turn-closed-after-sweep");
-                    }
-                }
-                if (vctx.notifyUser && notifiesBuild && turnErrored === false) {
-                    const userId = req._auth.verifiedAuth.claims.userId;
-                    const connId = clientWsSend(ctx).connId;
-                    const prefs = await loadNotificationPrefs(vctx, userId);
-                    if (shouldNotify(prefs, {
-                        notificationType: "build-complete",
-                        ownerHandle: resChat.ownerHandle,
-                        appSlug: resChat.appSlug,
-                    })) {
-                        const persisted = terminal.fsRef;
-                        const version = persisted === undefined
-                            ? undefined
-                            : await resolveBuildOrdinal(vctx, {
-                                ownerHandle: persisted.ownerHandle,
-                                appSlug: persisted.appSlug,
-                                fsId: persisted.fsId,
-                            });
-                        const fsId = persisted?.fsId;
-                        void vctx
-                            .notifyUser(userId, {
-                            type: "vibes.diy.evt-user-notification",
-                            notificationType: "build-complete",
-                            ownerHandle: resChat.ownerHandle,
-                            appSlug: resChat.appSlug,
-                            promptId,
-                            ...(fsId === undefined ? {} : { fsId }),
-                            ...(version === undefined ? {} : { version }),
-                        }, connId)
-                            .catch((_e) => {
-                        });
-                    }
-                }
-            }
         });
         return Result.Ok(EventoResult.Continue);
     }),