specrails-desktop 2.36.0 → 2.42.2

package/server/dist/blueprint-chat-manager.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlueprintChatManager = void 0;
+exports.BlueprintChatManager = exports.BUILDER_TURN_INTENTS = void 0;
+exports.planSnapshotRepair = planSnapshotRepair;
 const crypto_1 = require("crypto");
 const tree_kill_1 = __importDefault(require("tree-kill"));
 const providers_1 = require("./providers");
@@ -15,8 +16,30 @@ const desktop_db_1 = require("./desktop-db");
 const builder_cwd_manager_1 = require("./builder-cwd-manager");
 const blueprint_operator_prompt_1 = require("./blueprint-operator-prompt");
 const blueprint_draft_parser_1 = require("./blueprint-draft-parser");
+const blueprint_draft_parser_2 = require("./blueprint-draft-parser");
+const blueprint_generation_1 = require("./blueprint-generation");
+const blueprint_spec_quality_1 = require("./blueprint-spec-quality");
 const explore_draft_title_1 = require("./explore-draft-title");
 const blueprint_store_1 = require("./blueprint-store");
+exports.BUILDER_TURN_INTENTS = ['surprise', 'approve'];
+function repairKindForRejection(reason) {
+    return reason === 'truncated' ? 'truncated' : 'invalid_json';
+}
+/** Decide whether a settled parse needs ONE repair turn and what to ask. */
+function planSnapshotRepair(parse) {
+    if (!parse.blueprint) {
+        const last = parse.rejected[parse.rejected.length - 1];
+        if (!last)
+            return null;
+        const reasonNote = last.reason === 'missing_version' ? 'The payload must be the blueprint object itself with an integer blueprintVersion. ' : '';
+        return { kind: repairKindForRejection(last.reason), detail: `${reasonNote}${last.detail}` };
+    }
+    const audit = (0, blueprint_spec_quality_1.auditRawBlueprintForM1)(parse.rawBlueprint);
+    if (audit.claimsComplete && !audit.valid) {
+        return { kind: 'quality', detail: (0, blueprint_spec_quality_1.formatQualityIssuesForModel)(audit.issues) };
+    }
+    return null;
+}
 class BlueprintChatManager {
     _broadcast;
     _db;
@@ -115,7 +138,7 @@ class BlueprintChatManager {
             return;
         }
         try {
-            await this._runTurn(conversation, userText, options);
+            await this._runTurn(conversation, { userText, options });
         }
         catch (err) {
             if (this._disposed)
@@ -127,8 +150,64 @@ class BlueprintChatManager {
             this._abortedTurns.delete(conversationId);
         }
     }
-    async _runTurn(conversation, userText, options) {
+    /**
+     * Manual repair (the panel's "retry" after a rejected snapshot, or "ask the
+     * Builder to fix" after a failed audit). Decides what to ask from the
+     * PERSISTED state, so it works after a restart, and runs ONE repair turn on
+     * the same session. Resolves as soon as the turn is scheduled.
+     */
+    async repairSnapshot(conversationId, options = {}) {
+        if (this._disposed)
+            return { ok: false, reason: 'unknown_conversation' };
+        const conversation = (0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId);
+        if (!conversation)
+            return { ok: false, reason: 'unknown_conversation' };
+        if (this._active.has(conversationId))
+            return { ok: false, reason: 'streaming' };
+        const snapshot = (0, blueprint_store_1.getBlueprintSnapshot)(this._db, conversationId);
+        let repair = null;
+        if (snapshot.issue) {
+            repair = { kind: repairKindForRejection(snapshot.issue.reason), detail: snapshot.issue.detail };
+        }
+        else if (snapshot.rawBlueprint !== null) {
+            const audit = (0, blueprint_spec_quality_1.auditRawBlueprintForM1)(snapshot.rawBlueprint);
+            if (audit.claimsComplete && !audit.valid) {
+                repair = { kind: 'quality', detail: (0, blueprint_spec_quality_1.formatQualityIssuesForModel)(audit.issues) };
+            }
+        }
+        // A halted batched generation (outline or partly written specs, no
+        // rejection pending) resumes from the next unfilled range instead of
+        // re-asking for a whole snapshot.
+        const resume = !repair && !snapshot.issue && snapshot.rawBlueprint !== null
+            && (0, blueprint_generation_1.unfilledSpecIndices)(snapshot.rawBlueprint).length > 0;
+        if (!repair && !resume)
+            return { ok: false, reason: 'nothing_to_repair' };
+        const adapter = (0, providers_1.getAdapter)(conversation.provider);
+        if (!conversation.session_id || !adapter.capabilities.nativeResume)
+            return { ok: false, reason: 'no_session' };
+        const request = repair;
+        void (async () => {
+            try {
+                // Same model as the conversation; the composer's effort rides along so a
+                // manual retry / Continue generating runs exactly like a regular send.
+                const turnOptions = { reasoningEffort: options.reasoningEffort };
+                await this._runTurn(conversation, request ? { options: turnOptions, repair: request } : { options: turnOptions, resume: true });
+            }
+            catch (err) {
+                if (this._disposed)
+                    return;
+                console.error(`[blueprint-chat] repair turn failed (${conversationId}):`, err);
+                this._emitError(conversationId, err instanceof Error ? err.message : 'The Builder repair turn failed.');
+            }
+            finally {
+                this._abortedTurns.delete(conversationId);
+            }
+        })();
+        return { ok: true, kind: repair ? repair.kind : 'resume' };
+    }
+    async _runTurn(conversation, turn) {
         const conversationId = conversation.id;
+        const { options } = turn;
         const adapter = (0, providers_1.getAdapter)(conversation.provider);
         const toolPolicy = (0, runtime_1.pureOutputToolPolicy)(adapter);
         if (!toolPolicy) {
@@ -148,33 +227,42 @@ class BlueprintChatManager {
             : undefined;
         const cwd = (0, builder_cwd_manager_1.ensureBuilderCwd)();
         const timestamp = () => new Date().toISOString();
-        (0, blueprint_store_1.addBlueprintMessage)(this._db, { conversationId, role: 'user', content: userText });
-        // Deterministic title from the first user prompt (no AI spend).
-        if (!conversation.title) {
-            const title = (0, explore_draft_title_1.generateAutoTitle)([{ role: 'user', content: userText }]);
-            if (title) {
-                (0, blueprint_store_1.updateBlueprintConversation)(this._db, conversationId, { title });
+        // The session id the NEXT invocation resumes: the row's id at entry, then
+        // whatever the previous invocation captured (a repair turn must continue
+        // the session the rejected block came from).
+        let currentSessionId = conversation.session_id ?? null;
+        if (turn.userText !== undefined) {
+            (0, blueprint_store_1.addBlueprintMessage)(this._db, { conversationId, role: 'user', content: turn.userText, intent: options.intent ?? null });
+            // Deterministic title from the first user prompt (no AI spend).
+            if (!conversation.title) {
+                const title = (0, explore_draft_title_1.generateAutoTitle)([{ role: 'user', content: turn.userText }]);
+                if (title) {
+                    (0, blueprint_store_1.updateBlueprintConversation)(this._db, conversationId, { title });
+                }
             }
         }
-        const invoke = async (useResume) => {
+        const invoke = async (useResume, userText) => {
             const action = useResume ? 'chat-resume' : 'chat-turn';
             const startedAt = new Date().toISOString();
             let streamed = '';
-            let capturedSessionId = useResume ? conversation.session_id ?? null : null;
+            let capturedSessionId = useResume ? currentSessionId : null;
             let capturedError = null;
             // `chat-turn` / `chat-resume` intentionally ignore `systemPrompt` for
             // providers whose normal project-chat stance lives in their cwd
             // instructions file. The day-0 Builder has no project instructions, so
             // its schema/operator prompt must ride in the user prompt instead.
+            // Batched generation needs a resumable session; a provider without one
+            // is told to generate everything in a single reply (legacy protocol).
+            const effectiveUser = adapter.capabilities.nativeResume ? userText : `${userText}\n\n${blueprint_operator_prompt_1.SINGLE_RESPONSE_MODE_LINE}`;
             const prompt = adapter.capabilities.systemPromptArg
-                ? userText
-                : `${blueprint_operator_prompt_1.BUILDER_SYSTEM_PROMPT}\n\n---\n\n${userText}`;
+                ? effectiveUser
+                : `${blueprint_operator_prompt_1.BUILDER_SYSTEM_PROMPT}\n\n---\n\n${effectiveUser}`;
             console.log(`[blueprint-chat] turn start conv=${conversationId} provider=${adapter.id} action=${action} model=${model}`);
             const buildOpts = {
                 prompt,
                 systemPrompt: adapter.capabilities.systemPromptArg ? blueprint_operator_prompt_1.BUILDER_SYSTEM_PROMPT : undefined,
                 model,
-                sessionId: useResume ? conversation.session_id ?? undefined : undefined,
+                sessionId: useResume ? currentSessionId ?? undefined : undefined,
                 reasoning_effort: reasoningEffort,
                 toolPolicy,
             };
@@ -239,87 +327,413 @@ class BlueprintChatManager {
         const persistSession = (sessionId) => {
             if (this._disposed)
                 return;
+            currentSessionId = sessionId;
             if ((0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
                 (0, blueprint_store_1.updateBlueprintConversation)(this._db, conversationId, { session_id: sessionId });
             }
         };
-        // One agent_invocations row per settled turn, project_id NULL (day-0 spend).
+        // One agent_invocations row per settled invocation, project_id NULL
+        // (day-0 spend) — a repair turn is a second spawn and bills too.
         const record = (outcome, status) => {
             if (this._disposed || outcome.disposed)
                 return;
             this._recordTurn(conversation, adapter, model, outcome, status);
         };
-        const settleText = (r) => {
-            const { stripped, blueprint, rawBlueprint } = (0, blueprint_draft_parser_1.parseBlueprintDraftBlocks)(r.text);
+        /** Persist one assistant reply: stripped transcript + unstripped raw when
+         *  it carried a block. An empty stripped reply (block only) is still
+         *  stored so the raw payload survives; the API hides empty rows. */
+        const persistReply = (r, stripped, hadBlocks) => {
             const content = stripped.trim();
             if ((0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
-                (0, blueprint_store_1.addBlueprintMessage)(this._db, { conversationId, role: 'assistant', content: content || r.text });
+                (0, blueprint_store_1.addBlueprintMessage)(this._db, {
+                    conversationId,
+                    role: 'assistant',
+                    content: hadBlocks ? content : content || r.text,
+                    rawContent: hadBlocks ? r.text : null,
+                });
                 persistSession(r.sessionId);
             }
+            return hadBlocks ? content : content || r.text;
+        };
+        const persistAssistant = (r, parse) => {
+            // Generation fences (spec-detail / spec-audit) are stripped like
+            // blueprint-draft blocks — never raw JSON in the transcript.
+            const gen = (0, blueprint_generation_1.parseGenerationBlocks)(parse.stripped);
+            return persistReply(r, gen.stripped, parse.hadBlocks || gen.hadBlocks);
+        };
+        /**
+         * Apply a reply to a base snapshot (D7 patch protocol): a full
+         * blueprint-draft block wins; otherwise spec-detail / spec-audit blocks are
+         * merged into `baseRaw` by index. Returns the parse-shaped result the
+         * finish path understands, plus the transcript-safe text.
+         */
+        const applyReply = (text, baseRaw) => {
+            const parse = (0, blueprint_draft_parser_1.parseBlueprintDraftBlocks)(text);
+            const gen = (0, blueprint_generation_1.parseGenerationBlocks)(parse.stripped);
+            if (parse.blueprint)
+                return { parse: { ...parse, stripped: gen.stripped }, stripped: gen.stripped, hadBlocks: true, gen };
+            const patches = [...gen.details, ...(gen.audit?.fixes ?? [])];
+            // An audit verdict is a patch even with zero fixes (it flips specsComplete).
+            if ((patches.length > 0 || gen.audit) && baseRaw !== null && baseRaw !== undefined) {
+                let merged = (0, blueprint_generation_1.mergeSpecDetails)(baseRaw, patches);
+                if (gen.audit)
+                    merged = (0, blueprint_generation_1.withSpecsComplete)(merged, gen.audit.specsComplete);
+                const blueprint = (0, blueprint_draft_parser_2.coerceBlueprint)(merged);
+                if (blueprint) {
+                    return {
+                        parse: { stripped: gen.stripped, blueprint, rawBlueprint: merged, hadBlocks: true, rejected: parse.rejected, repaired: false, truncated: gen.truncated },
+                        stripped: gen.stripped, hadBlocks: true, gen,
+                    };
+                }
+            }
+            const rejected = gen.rejected.length > 0 && parse.rejected.length === 0 && !parse.blueprint
+                ? [...parse.rejected, { index: 0, reason: gen.truncated ? 'truncated' : 'invalid_json', detail: gen.rejected.join('; ') }]
+                : parse.rejected;
+            return { parse: { ...parse, stripped: gen.stripped, rejected, hadBlocks: parse.hadBlocks || gen.hadBlocks }, stripped: gen.stripped, hadBlocks: parse.hadBlocks || gen.hadBlocks, gen };
+        };
+        const finishTurn = (fullText, parse, meta) => {
+            let snapshot;
+            if (parse.blueprint) {
+                const audit = (0, blueprint_spec_quality_1.auditRawBlueprintForM1)(parse.rawBlueprint);
+                snapshot = {
+                    status: 'accepted',
+                    repaired: parse.repaired || meta.fromRepairTurn,
+                    repairAttempted: meta.repairAttempted,
+                    claimsComplete: audit.claimsComplete,
+                    ...(audit.claimsComplete && !audit.valid ? { qualityIssues: audit.issues } : {}),
+                    ...(meta.generation ? { generation: meta.generation } : {}),
+                    ...(meta.continuing ? { continuing: true } : {}),
+                    ...(meta.generationHalted ? { generationHalted: true } : {}),
+                };
+                if ((0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
+                    (0, blueprint_store_1.saveBlueprintSnapshot)(this._db, conversationId, { blueprint: parse.blueprint, rawBlueprint: parse.rawBlueprint });
+                }
+            }
+            else if (parse.rejected.length > 0) {
+                const last = parse.rejected[parse.rejected.length - 1];
+                snapshot = { status: 'rejected', reason: last.reason, detail: last.detail, repairAttempted: meta.repairAttempted };
+                if ((0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
+                    (0, blueprint_store_1.saveBlueprintSnapshotIssue)(this._db, conversationId, { reason: last.reason, detail: last.detail, at: timestamp() });
+                }
+                console.warn(`[blueprint-chat] snapshot rejected conv=${conversationId} reason=${last.reason} repairAttempted=${meta.repairAttempted}: ${last.detail}`);
+            }
+            else {
+                snapshot = { status: 'none' };
+            }
             this._broadcast({
                 type: 'blueprint.done',
                 conversationId,
-                fullText: content || r.text,
-                blueprint,
-                rawBlueprint,
+                fullText,
+                blueprint: parse.blueprint,
+                rawBlueprint: parse.rawBlueprint,
+                snapshot,
+                ...(meta.continuing ? { continuing: true } : {}),
                 timestamp: timestamp(),
             });
         };
-        const canResume = !!conversation.session_id && adapter.capabilities.nativeResume;
-        let r = await invoke(canResume);
-        if (this._disposed || r.disposed)
-            return;
-        if (!(0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
-            record(r, 'aborted'); // deleted mid-turn; the spawn still billed
-            return;
-        }
-        if (this._abortedTurns.delete(conversationId)) {
-            if (r.text)
-                settleText(r);
-            record(r, 'aborted');
-            return;
-        }
-        // Auto-heal a stale session: a resume with no text retries once fresh.
-        if (canResume && !r.spawnFailed && !r.error && !r.text) {
-            (0, blueprint_store_1.updateBlueprintConversation)(this._db, conversationId, { session_id: null });
-            r = await invoke(false);
+        /** Shared post-invocation triage. Returns the outcome to continue with, or
+         *  null when the turn is over (disposed / deleted / aborted / failed). */
+        const settle = async (first, allowAutoHeal) => {
+            let r = first;
             if (this._disposed || r.disposed)
-                return;
+                return null;
             if (!(0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
+                record(r, 'aborted'); // deleted mid-turn; the spawn still billed
+                return null;
+            }
+            if (this._abortedTurns.delete(conversationId)) {
+                if (r.text) {
+                    const parse = (0, blueprint_draft_parser_1.parseBlueprintDraftBlocks)(r.text);
+                    finishTurn(persistAssistant(r, parse), parse, { repairAttempted: false, fromRepairTurn: false });
+                }
                 record(r, 'aborted');
-                return;
+                return null;
+            }
+            // Auto-heal a stale session: a resume with no text retries once fresh.
+            if (allowAutoHeal && !r.spawnFailed && !r.error && !r.text) {
+                (0, blueprint_store_1.updateBlueprintConversation)(this._db, conversationId, { session_id: null });
+                currentSessionId = null;
+                r = await invoke(false, turn.userText ?? '');
+                if (this._disposed || r.disposed)
+                    return null;
+                if (!(0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
+                    record(r, 'aborted');
+                    return null;
+                }
+                if (this._abortedTurns.delete(conversationId)) {
+                    if (r.text) {
+                        const parse = (0, blueprint_draft_parser_1.parseBlueprintDraftBlocks)(r.text);
+                        finishTurn(persistAssistant(r, parse), parse, { repairAttempted: false, fromRepairTurn: false });
+                    }
+                    record(r, 'aborted');
+                    return null;
+                }
+            }
+            if (r.spawnFailed) {
+                this._emitError(conversationId, `Failed to launch ${adapter.binary}. Is it installed and on PATH?`);
+                record(r, 'failed');
+                return null;
+            }
+            if (r.error || r.code !== 0) {
+                persistSession(null);
+                const reason = r.error ||
+                    (r.stderrTail ? r.stderrTail.split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300) : '') ||
+                    `${adapter.binary} exited with code ${r.code ?? 'unknown'}`;
+                this._emitError(conversationId, reason);
+                record(r, 'failed');
+                return null;
+            }
+            if (!r.text) {
+                persistSession(null);
+                const reason = (r.stderrTail ? r.stderrTail.split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300) : '') ||
+                    'The Builder returned no output.';
+                this._emitError(conversationId, reason);
+                record(r, 'failed');
+                return null;
+            }
+            return r;
+        };
+        /** Repair-turn triage (mirrors `settle` minus the auto-heal and the error
+         *  broadcasts — a failed repair never turns a successful user turn into an
+         *  error): 'stop' = the turn is over (disposed / deleted / aborted), null =
+         *  the repair spawn produced nothing usable (the original outcome stands). */
+        const settleRepair = (r) => {
+            if (this._disposed || r.disposed)
+                return 'stop';
+            if (!(0, blueprint_store_1.getBlueprintConversation)(this._db, conversationId)) {
+                record(r, 'aborted');
+                return 'stop';
             }
             if (this._abortedTurns.delete(conversationId)) {
-                if (r.text)
-                    settleText(r);
                 record(r, 'aborted');
+                return 'stop';
+            }
+            if (r.spawnFailed || r.error || r.code !== 0 || !r.text) {
+                console.warn(`[blueprint-chat] repair turn produced no usable reply conv=${conversationId} code=${r.code} error=${r.error ?? ''}`);
+                record(r, 'failed');
+                return null;
+            }
+            return r;
+        };
+        const canResume = !!currentSessionId && adapter.capabilities.nativeResume;
+        /** The quality-repair tail (one automatic repair turn when the model's
+         *  block was unusable, or it claimed completion and the gate disagrees).
+         *  Patch-aware: a repair reply may be spec-detail blocks merged into the
+         *  snapshot, or a full blueprint-draft block. */
+        const finishWithQualityRepair = async (text, current, meta) => {
+            const repair = planSnapshotRepair(current);
+            const canRepair = repair !== null && !!currentSessionId && adapter.capabilities.nativeResume;
+            if (!repair || !canRepair) {
+                finishTurn(text, current, { repairAttempted: false, fromRepairTurn: false, ...meta });
                 return;
             }
-        }
-        if (r.spawnFailed) {
-            this._emitError(conversationId, `Failed to launch ${adapter.binary}. Is it installed and on PATH?`);
-            record(r, 'failed');
+            console.warn(`[blueprint-chat] snapshot needs repair conv=${conversationId} kind=${repair.kind}: ${repair.detail.slice(0, 200)}`);
+            this._broadcast({
+                type: 'blueprint.repairing',
+                conversationId,
+                kind: repair.kind,
+                attempt: 1,
+                manual: false,
+                timestamp: timestamp(),
+            });
+            const r2 = settleRepair(await invoke(true, (0, blueprint_operator_prompt_1.buildSnapshotRepairPrompt)(repair.kind, repair.detail)));
+            if (r2 === 'stop')
+                return;
+            if (r2 === null) {
+                // The repair spawn failed — the original turn still stands.
+                finishTurn(text, current, { repairAttempted: true, fromRepairTurn: false, ...meta });
+                return;
+            }
+            const applied = applyReply(r2.text, current.rawBlueprint);
+            const prose2 = persistReply(r2, applied.stripped, applied.hadBlocks);
+            record(r2, 'success');
+            const combinedText = prose2 ? (text ? `${text}\n\n${prose2}` : prose2) : text;
+            if (applied.parse.blueprint) {
+                finishTurn(combinedText, applied.parse, { repairAttempted: true, fromRepairTurn: true, ...meta });
+            }
+            else {
+                // Still unusable: report the ORIGINAL outcome (plus the newest
+                // rejection detail when the repair produced one) so the UI can offer a
+                // manual retry with the freshest diagnostic.
+                const merged = applied.parse.rejected.length > 0
+                    ? { ...current, rejected: [...current.rejected, ...applied.parse.rejected] }
+                    : current;
+                finishTurn(combinedText, merged, { repairAttempted: true, fromRepairTurn: false, ...meta });
+            }
+        };
+        // ── App-driven batched generation (D7). An OUTLINE snapshot (every spec
+        // named, no bodies) on a resumable session starts the detail → audit
+        // drive: the app asks for two specs per turn as spec-detail blocks, merges
+        // them by index, announces each phase, keeps the panel live after every
+        // turn (`continuing`), then runs one audit turn and the normal quality
+        // repair. Depth is no longer capped by a single reply's output budget.
+        const driveGeneration = async (initialRaw, fullText, base, mode) => {
+            let raw = initialRaw;
+            const total = (0, blueprint_generation_1.specTitles)(raw).length;
+            const totalTurns = (0, blueprint_generation_1.projectedGenerationTurns)(total);
+            // A resume re-derives the turn ordinal from what is already written so
+            // the "turn x/y" pill stays truthful and the budget covers the rest.
+            let turnNo = mode === 'resume'
+                ? 1 + Math.ceil((total - (0, blueprint_generation_1.unfilledSpecIndices)(raw).length) / blueprint_generation_1.SPECS_PER_DETAIL_TURN)
+                : 1;
+            const descriptor = (phase, from, to) => ({ phase, from, to, total, turn: turnNo, totalTurns });
+            const announce = (phase, from, to) => {
+                this._broadcast({ type: 'blueprint.generating', conversationId, ...descriptor(phase, from, to), timestamp: timestamp() });
+            };
+            const snapshotOf = (rawSnapshot) => ({
+                stripped: '', blueprint: (0, blueprint_draft_parser_2.coerceBlueprint)(rawSnapshot) ?? base.blueprint, rawBlueprint: rawSnapshot,
+                hadBlocks: true, rejected: [], repaired: base.repaired, truncated: false,
+            });
+            const emitContinuing = (rawSnapshot, generation) => {
+                finishTurn('', snapshotOf(rawSnapshot), { repairAttempted: false, fromRepairTurn: false, generation, continuing: true });
+            };
+            const halt = (rawSnapshot, generation) => {
+                console.warn(`[blueprint-chat] generation halted conv=${conversationId} phase=${generation.phase} turn=${turnNo}/${totalTurns}`);
+                finishTurn(fullText, snapshotOf((0, blueprint_generation_1.withSpecsComplete)(rawSnapshot, false)), { repairAttempted: true, fromRepairTurn: false, generation, generationHalted: true });
+            };
+            // The outline itself is the first accepted frame of the drive; a resume
+            // re-announces the next range so the panel leaves its halted state.
+            let range = (0, blueprint_generation_1.nextDetailRange)(raw);
+            emitContinuing(raw, mode === 'resume' && range
+                ? descriptor('details', range.from + 1, range.to + 1)
+                : descriptor('outline', 0, 0));
+            while (range) {
+                if (turnNo >= blueprint_generation_1.MAX_GENERATION_TURNS) {
+                    halt(raw, descriptor('details', range.from + 1, range.to + 1));
+                    return;
+                }
+                turnNo += 1;
+                const titles = (0, blueprint_generation_1.specTitles)(raw);
+                announce('details', range.from + 1, range.to + 1);
+                const r2 = settleRepair(await invoke(true, (0, blueprint_generation_1.buildDetailPrompt)(range, titles)));
+                if (r2 === 'stop')
+                    return;
+                if (r2 === null) {
+                    halt(raw, descriptor('details', range.from + 1, range.to + 1));
+                    return;
+                }
+                const applied = applyReply(r2.text, raw);
+                persistReply(r2, applied.stripped, applied.hadBlocks);
+                record(r2, 'success');
+                let merged = applied.parse.blueprint ? applied.parse.rawBlueprint : raw;
+                if (!(0, blueprint_generation_1.rangeFilled)(merged, range) && turnNo < blueprint_generation_1.MAX_GENERATION_TURNS) {
+                    // ONE repair for this range (a cut-off or malformed block).
+                    turnNo += 1;
+                    announce('repair', range.from + 1, range.to + 1);
+                    const detail = applied.gen.rejected.join('; ') || 'no spec-detail block for the requested indexes';
+                    const r3 = settleRepair(await invoke(true, (0, blueprint_generation_1.buildDetailRepairPrompt)(range, titles, detail)));
+                    if (r3 === 'stop')
+                        return;
+                    if (r3 !== null) {
+                        const applied3 = applyReply(r3.text, merged);
+                        persistReply(r3, applied3.stripped, applied3.hadBlocks);
+                        record(r3, 'success');
+                        if (applied3.parse.blueprint)
+                            merged = applied3.parse.rawBlueprint;
+                    }
+                }
+                raw = (0, blueprint_generation_1.withSpecsComplete)(merged, false);
+                if (!(0, blueprint_generation_1.rangeFilled)(raw, range)) {
+                    halt(raw, descriptor('details', range.from + 1, range.to + 1));
+                    return;
+                }
+                emitContinuing(raw, descriptor('details', range.from + 1, range.to + 1));
+                range = (0, blueprint_generation_1.nextDetailRange)(raw);
+            }
+            // Audit turn: the model self-audits the whole batch and may patch specs.
+            if (turnNo < blueprint_generation_1.MAX_GENERATION_TURNS) {
+                turnNo += 1;
+                announce('audit', 1, total);
+                const ra = settleRepair(await invoke(true, (0, blueprint_generation_1.buildAuditPrompt)()));
+                if (ra === 'stop')
+                    return;
+                if (ra !== null) {
+                    const appliedAudit = applyReply(ra.text, raw);
+                    persistReply(ra, appliedAudit.stripped, appliedAudit.hadBlocks);
+                    record(ra, 'success');
+                    if (appliedAudit.parse.blueprint)
+                        raw = appliedAudit.parse.rawBlueprint;
+                    const verdict = appliedAudit.gen.audit;
+                    if (!verdict) {
+                        // A reply without a spec-audit verdict: let the deterministic gate judge.
+                        raw = (0, blueprint_generation_1.withSpecsComplete)(raw, true);
+                    }
+                    else if (!verdict.specsComplete && verdict.issues.length > 0 && turnNo < blueprint_generation_1.MAX_GENERATION_TURNS) {
+                        // The model found blocking problems: ONE corrections turn (spec-detail
+                        // patches for the affected specs), then the deterministic gate judges.
+                        turnNo += 1;
+                        announce('repair', 1, total);
+                        const rc = settleRepair(await invoke(true, (0, blueprint_generation_1.buildAuditIssuesPrompt)(verdict.issues)));
+                        if (rc === 'stop')
+                            return;
+                        if (rc !== null) {
+                            const appliedFix = applyReply(rc.text, raw);
+                            persistReply(rc, appliedFix.stripped, appliedFix.hadBlocks);
+                            record(rc, 'success');
+                            if (appliedFix.parse.blueprint)
+                                raw = appliedFix.parse.rawBlueprint;
+                        }
+                        raw = (0, blueprint_generation_1.withSpecsComplete)(raw, true);
+                    }
+                    else if (!verdict.specsComplete) {
+                        // No actionable issues (or no turn budget left): let the gate judge.
+                        raw = (0, blueprint_generation_1.withSpecsComplete)(raw, true);
+                    }
+                }
+                else {
+                    raw = (0, blueprint_generation_1.withSpecsComplete)(raw, true);
+                }
+            }
+            else {
+                raw = (0, blueprint_generation_1.withSpecsComplete)(raw, true);
+            }
+            await finishWithQualityRepair(fullText, snapshotOf(raw), { generation: descriptor('audit', 1, total) });
+        };
+        // ── Manual repair turn: the request IS the repair; never nests another.
+        if (turn.repair) {
+            this._broadcast({
+                type: 'blueprint.repairing',
+                conversationId,
+                kind: turn.repair.kind,
+                attempt: 1,
+                manual: true,
+                timestamp: timestamp(),
+            });
+            const r = await settle(await invoke(canResume, (0, blueprint_operator_prompt_1.buildSnapshotRepairPrompt)(turn.repair.kind, turn.repair.detail)), false);
+            if (!r)
+                return;
+            const base = (0, blueprint_store_1.getBlueprintSnapshot)(this._db, conversationId).rawBlueprint;
+            const applied = applyReply(r.text, base);
+            const fullText = persistReply(r, applied.stripped, applied.hadBlocks);
+            record(r, 'success');
+            finishTurn(fullText, applied.parse, { repairAttempted: true, fromRepairTurn: true });
             return;
         }
-        if (r.error || r.code !== 0) {
-            persistSession(null);
-            const reason = r.error ||
-                (r.stderrTail ? r.stderrTail.split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300) : '') ||
-                `${adapter.binary} exited with code ${r.code ?? 'unknown'}`;
-            this._emitError(conversationId, reason);
-            record(r, 'failed');
+        // ── Resume a halted batched generation (manual "Continue generating").
+        if (turn.resume) {
+            const persisted = (0, blueprint_store_1.getBlueprintSnapshot)(this._db, conversationId).rawBlueprint;
+            const blueprint = (0, blueprint_draft_parser_2.coerceBlueprint)(persisted);
+            if (!blueprint || (0, blueprint_generation_1.unfilledSpecIndices)(persisted).length === 0)
+                return;
+            await driveGeneration(persisted, '', { blueprint, repaired: false }, 'resume');
             return;
         }
-        if (r.text) {
-            settleText(r);
-            record(r, 'success');
+        // ── Regular user turn.
+        const r = await settle(await invoke(canResume, turn.userText ?? ''), canResume);
+        if (!r)
+            return;
+        const parse = (0, blueprint_draft_parser_1.parseBlueprintDraftBlocks)(r.text);
+        const fullText = persistAssistant(r, parse);
+        record(r, 'success');
+        // ── App-driven batched generation (D7): an OUTLINE snapshot on a
+        // resumable session starts the detail → audit drive.
+        const canDrive = parse.blueprint !== null && (0, blueprint_generation_1.isOutlineSnapshot)(parse.rawBlueprint)
+            && !!currentSessionId && adapter.capabilities.nativeResume;
+        if (canDrive) {
+            await driveGeneration(parse.rawBlueprint, fullText, { blueprint: parse.blueprint, repaired: parse.repaired }, 'outline');
             return;
         }
-        persistSession(null);
-        const reason = (r.stderrTail ? r.stderrTail.split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300) : '') ||
-            'The Builder returned no output.';
-        this._emitError(conversationId, reason);
-        record(r, 'failed');
+        await finishWithQualityRepair(fullText, parse, {});
     }
     _recordTurn(conversation, adapter, model, outcome, status) {
         if (this._disposed)