specrails-desktop 2.36.0 → 2.42.2

package/server/dist/blueprint-commit.js

@@ -12,6 +12,7 @@ const path_1 = __importDefault(require("path"));
 const crypto_1 = require("crypto");
 const win_spawn_1 = require("./util/win-spawn");
 const desktop_db_1 = require("./desktop-db");
+const blueprint_store_1 = require("./blueprint-store");
 const providers_1 = require("./providers");
 const blueprint_draft_parser_1 = require("./blueprint-draft-parser");
 const blueprint_types_1 = require("./blueprint-types");
@@ -104,6 +105,10 @@ function createBlueprintCommitRunner(deps) {
         assemble: deps.io?.assemble ?? (async (opts) => { await (0, offline_assemble_1.assembleProjectOffline)(opts); }),
         writePair: deps.io?.writePair ?? blueprint_render_1.writeBlueprintPair,
         mutateTickets: deps.io?.mutateTickets ?? ((filePath, fn) => { (0, ticket_store_1.mutateStore)(filePath, fn); }),
+        markCommitted: deps.io?.markCommitted ??
+            ((conversationId, projectId) => {
+                (0, blueprint_store_1.markBlueprintCommitted)(deps.registry.desktopDb, conversationId, projectId);
+            }),
         registerProject: deps.io?.registerProject ??
             ((opts) => {
                 const ctx = deps.registry.addProject({
@@ -148,6 +153,9 @@ function createBlueprintCommitRunner(deps) {
             return { ok: false, error: 'm1_specs_over_cap', detail: `max ${blueprint_types_1.M1_SPECS_MAX}` };
         }
         const rawBlueprint = input.blueprint;
+        if (Array.isArray(rawBlueprint.m1Specs) && rawBlueprint.m1Specs.some((spec) => spec && typeof spec === 'object' && Object.prototype.hasOwnProperty.call(spec, 'repositoryIds'))) {
+            return { ok: false, error: 'invalid_repository_ids', detail: 'A new Builder project uses its primary repository. Add repository scope after the project and its repository IDs exist.' };
+        }
         const quality = (0, blueprint_spec_quality_1.analyzeBuilderSpecBatch)({
             specsComplete: rawBlueprint.specsComplete,
             specs: Array.isArray(rawBlueprint.m1Specs) ? rawBlueprint.m1Specs : [],
@@ -174,7 +182,11 @@ function createBlueprintCommitRunner(deps) {
         catch {
             /* unreadable registry — never block on the projection; addProject re-mirrors */
         }
-        return { ok: true, blueprint, name, location, providers, createGithubRepo: input.createGithubRepo === true };
+        const conversationId = typeof input.conversationId === 'string' && input.conversationId
+            && (0, blueprint_store_1.getBlueprintConversation)(deps.registry.desktopDb, input.conversationId)
+            ? input.conversationId
+            : null;
+        return { ok: true, blueprint, name, location, providers, createGithubRepo: input.createGithubRepo === true, conversationId };
     };
     const start = (input) => {
         const validated = validate(input);
@@ -283,6 +295,14 @@ function createBlueprintCommitRunner(deps) {
             emit(commitId, step, 'running');
             io.registerProject({ id: projectId, slug, name, path: location, providers });
             emit(commitId, step, 'done');
+            if (v.conversationId) {
+                try {
+                    io.markCommitted(v.conversationId, projectId);
+                }
+                catch (err) {
+                    console.warn(`[blueprint-commit] could not link conversation ${v.conversationId}:`, err.message);
+                }
+            }
             // 7. best-effort GitHub remote — never aborts. Pre-flight guards against
             // a stale client cache sending createGithubRepo with gh absent/unauthed.
             if (v.createGithubRepo) {

package/server/dist/blueprint-draft-parser.js

@@ -8,13 +8,69 @@
 // Streaming tail cut: the fence regex only matches CLOSED fences, so an
 // unterminated trailing block is never parsed. `cutUnterminatedBlock` lets
 // stream renderers hide the raw open fence while it is still arriving.
+//
+// Nothing is dropped silently any more: every block that could not become a
+// snapshot is reported in `rejected` (invalid JSON after the tolerant repair
+// pass, missing `blueprintVersion`, or a block the output limit cut off before
+// its closing fence — `truncated`). The chat manager turns those into an
+// automatic repair turn and the UI into a precise, actionable notice.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.promoteJsonBlueprintFences = promoteJsonBlueprintFences;
+exports.countStartedSpecs = countStartedSpecs;
 exports.coerceBlueprint = coerceBlueprint;
 exports.parseBlueprintDraftBlocks = parseBlueprintDraftBlocks;
 exports.cutUnterminatedBlock = cutUnterminatedBlock;
 const blueprint_types_1 = require("./blueprint-types");
+const json_tolerant_1 = require("./json-tolerant");
 const FENCE_RE = /```blueprint-draft\s*\n([\s\S]*?)\n\s*```/g;
 const OPEN_FENCE_RE = /```blueprint-draft(?![\s\S]*?\n\s*```)/;
+// Fence tolerance: models mirror the schema example and sometimes emit the
+// snapshot inside a ```json (or bare) fence. A closed json/bare block whose
+// body is a `{…}` object carrying an integer `blueprintVersion` IS a snapshot
+// — it is promoted to a blueprint-draft fence before parsing so the panel
+// fills and the raw JSON never lands in the transcript. Never applied inside
+// a proper blueprint-draft block (the nested-json case is handled there).
+const JSON_BLUEPRINT_FENCE_RE = /```(?:json|JSON)?[ \t]*\r?\n(?=[ \t]*\{)([\s\S]*?)\r?\n[ \t]*```(?=[ \t]*(?:\r?\n|$))/g;
+const OPEN_JSON_BLUEPRINT_FENCE_RE = /```(?:json|JSON)?[ \t]*\r?\n[ \t]*\{(?=[\s\S]*"blueprintVersion")(?![\s\S]*?\n[ \t]*```)/;
+/** A lone closing fence right after a matched block — left behind when the
+ *  model nested a ```json fence inside the blueprint-draft one. */
+const ORPHAN_CLOSE_RE = /^[ \t]*\r?\n?[ \t]*```[ \t]*(?=\r?\n|$)/;
+/** Promote json / bare fenced blueprint objects to blueprint-draft fences
+ *  (outside proper blueprint-draft blocks). Exported for the client mirror
+ *  tests' parity checks. */
+function promoteJsonBlueprintFences(text) {
+    if (!text || !text.includes('"blueprintVersion"'))
+        return text ?? '';
+    const promoteGap = (gap) => {
+        if (!gap.includes('```') || !gap.includes('"blueprintVersion"'))
+            return gap;
+        JSON_BLUEPRINT_FENCE_RE.lastIndex = 0;
+        return gap.replace(JSON_BLUEPRINT_FENCE_RE, (whole, body) => {
+            if (!body.includes('"blueprintVersion"'))
+                return whole;
+            const parsed = (0, json_tolerant_1.parseJsonTolerant)(body);
+            if (!parsed.ok || !coerceBlueprint(parsed.value))
+                return whole;
+            return '```blueprint-draft\n' + body + '\n```';
+        });
+    };
+    let out = '';
+    let cursor = 0;
+    FENCE_RE.lastIndex = 0;
+    let m;
+    while ((m = FENCE_RE.exec(text)) !== null) {
+        out += promoteGap(text.slice(cursor, m.index)) + m[0];
+        cursor = m.index + m[0].length;
+    }
+    return out + promoteGap(text.slice(cursor));
+}
+/** Rough count of specs that had started in a (possibly truncated) block. */
+function countStartedSpecs(blockText) {
+    const at = blockText.indexOf('"m1Specs"');
+    if (at === -1)
+        return 0;
+    return (blockText.slice(at).match(/"title"\s*:/g) ?? []).length;
+}
 function asString(value) {
     return typeof value === 'string' ? value : '';
 }
@@ -89,6 +145,9 @@ function coerceM1Specs(value) {
         if (typeof obj.dependsOnIndex === 'number' && Number.isInteger(obj.dependsOnIndex) && obj.dependsOnIndex >= 0) {
             spec.dependsOnIndex = obj.dependsOnIndex;
         }
+        if (Array.isArray(obj.repositoryIds) && obj.repositoryIds.length > 0 && obj.repositoryIds.every((id) => typeof id === 'string' && id.trim()) && new Set(obj.repositoryIds).size === obj.repositoryIds.length) {
+            spec.repositoryIds = [...obj.repositoryIds];
+        }
         out.push(spec);
     }
     return out;
@@ -121,36 +180,82 @@ function coerceBlueprint(parsed) {
  * every block (valid or malformed) stripped, plus the LAST valid snapshot.
  * Never throws.
  */
-function parseBlueprintDraftBlocks(text) {
-    if (!text || !text.includes('```blueprint-draft')) {
-        return { stripped: text ?? '', blueprint: null, rawBlueprint: null, hadBlocks: false };
+function parseBlueprintDraftBlocks(input) {
+    const text = promoteJsonBlueprintFences(input ?? '');
+    if (!text || (!text.includes('```blueprint-draft') && !OPEN_JSON_BLUEPRINT_FENCE_RE.test(text))) {
+        return {
+            stripped: text ?? '',
+            blueprint: null,
+            rawBlueprint: null,
+            hadBlocks: false,
+            rejected: [],
+            repaired: false,
+            truncated: false,
+        };
     }
     let blueprint = null;
     let rawBlueprint = null;
+    let repaired = false;
     let hadBlocks = false;
+    const rejected = [];
     let stripped = '';
     let cursor = 0;
+    let index = 0;
     FENCE_RE.lastIndex = 0;
     let match;
     while ((match = FENCE_RE.exec(text)) !== null) {
         hadBlocks = true;
         stripped += text.slice(cursor, match.index);
         cursor = match.index + match[0].length;
-        let parsed;
-        try {
-            parsed = JSON.parse(match[1]);
+        const orphan = ORPHAN_CLOSE_RE.exec(text.slice(cursor));
+        if (orphan) {
+            cursor += orphan[0].length;
+            FENCE_RE.lastIndex = cursor;
         }
-        catch {
-            continue; // malformed; drop silently, keep the previous valid snapshot
+        const blockIndex = index;
+        index += 1;
+        const parsed = (0, json_tolerant_1.parseJsonTolerant)(match[1]);
+        if (!parsed.ok) {
+            const where = parsed.excerpt ? ` near: …${parsed.excerpt}…` : '';
+            rejected.push({ index: blockIndex, reason: 'invalid_json', detail: `${parsed.error}${where}` });
+            continue; // keep the previous valid snapshot
         }
-        const candidate = coerceBlueprint(parsed);
-        if (candidate) {
-            blueprint = candidate;
-            rawBlueprint = parsed;
+        const candidate = coerceBlueprint(parsed.value);
+        if (!candidate) {
+            rejected.push({
+                index: blockIndex,
+                reason: 'missing_version',
+                detail: 'the payload is not a blueprint object with an integer blueprintVersion',
+            });
+            continue;
         }
+        blueprint = candidate;
+        rawBlueprint = parsed.value;
+        repaired = parsed.repaired;
     }
-    stripped += text.slice(cursor);
-    return { stripped, blueprint, rawBlueprint, hadBlocks };
+    const remainder = text.slice(cursor);
+    const open = OPEN_FENCE_RE.exec(remainder) ?? OPEN_JSON_BLUEPRINT_FENCE_RE.exec(remainder);
+    let truncated = false;
+    if (open) {
+        // The reply ended inside a block: the output limit cut it off. Never let
+        // the partial JSON reach the transcript; report how far it got instead.
+        hadBlocks = true;
+        truncated = true;
+        const partial = remainder.slice(open.index);
+        const started = countStartedSpecs(partial);
+        rejected.push({
+            index,
+            reason: 'truncated',
+            detail: started > 0
+                ? `the block was cut off before its closing fence after ${started} spec title(s) had started`
+                : 'the block was cut off before its closing fence',
+        });
+        stripped += remainder.slice(0, open.index);
+    }
+    else {
+        stripped += remainder;
+    }
+    return { stripped, blueprint, rawBlueprint, hadBlocks, rejected, repaired, truncated };
 }
 /**
  * For live stream rendering: cut an UNTERMINATED trailing `blueprint-draft`
@@ -159,9 +264,9 @@ function parseBlueprintDraftBlocks(text) {
  * parser on the settled text instead.
  */
 function cutUnterminatedBlock(text) {
-    if (!text || !text.includes('```blueprint-draft'))
-        return text ?? '';
-    const match = OPEN_FENCE_RE.exec(text);
+    if (!text)
+        return '';
+    const match = (text.includes('```blueprint-draft') ? OPEN_FENCE_RE.exec(text) : null) ?? OPEN_JSON_BLUEPRINT_FENCE_RE.exec(text);
     if (!match)
         return text;
     return text.slice(0, match.index);

package/server/dist/blueprint-generation.js

@@ -0,0 +1,238 @@
+"use strict";
+// App-driven batched generation for the Project Builder (premium-milestone-
+// progress D7). Pure helpers — the BlueprintChatManager drives the turns.
+//
+// Why: "emit all 5–10 specs in ONE response" capped every spec's depth by the
+// output budget. The premium protocol splits generation:
+//   1. OUTLINE — one full `blueprint-draft` snapshot, every spec with its
+//      kind/title/summary/priority/labels/dependency and EMPTY body.
+//   2. DETAIL turns — the app asks for two specs at a time; the model answers
+//      with `spec-detail` fenced blocks ({ index, spec }) — small, focused
+//      payloads the app merges into the snapshot by index.
+//   3. AUDIT turn — the model answers with one `spec-audit` block
+//      ({ specsComplete, issues[], fixes[] }); the app merges the fixes, sets
+//      specsComplete and runs the deterministic gate as before.
+// Transcript hygiene: the generation fences are stripped exactly like
+// blueprint-draft blocks (never shown as raw JSON).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_GENERATION_TURNS = exports.SPECS_PER_DETAIL_TURN = void 0;
+exports.isOutlineSnapshot = isOutlineSnapshot;
+exports.unfilledSpecIndices = unfilledSpecIndices;
+exports.nextDetailRange = nextDetailRange;
+exports.projectedGenerationTurns = projectedGenerationTurns;
+exports.specTitles = specTitles;
+exports.buildDetailPrompt = buildDetailPrompt;
+exports.buildAuditPrompt = buildAuditPrompt;
+exports.buildDetailRepairPrompt = buildDetailRepairPrompt;
+exports.buildAuditIssuesPrompt = buildAuditIssuesPrompt;
+exports.parseGenerationBlocks = parseGenerationBlocks;
+exports.mergeSpecDetails = mergeSpecDetails;
+exports.withSpecsComplete = withSpecsComplete;
+exports.rangeFilled = rangeFilled;
+exports.cutUnterminatedGenerationBlock = cutUnterminatedGenerationBlock;
+const json_tolerant_1 = require("./json-tolerant");
+const blueprint_types_1 = require("./blueprint-types");
+exports.SPECS_PER_DETAIL_TURN = 2;
+/** Outline + detail turns + audit + one repair — 10 specs ⇒ 1 + 5 + 1 + 1. */
+exports.MAX_GENERATION_TURNS = 8;
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function specList(raw) {
+    const source = record(raw);
+    if (!source || !Array.isArray(source.m1Specs))
+        return null;
+    return source.m1Specs.map((s) => record(s) ?? {});
+}
+function specIsEmpty(spec) {
+    const description = typeof spec.description === 'string' ? spec.description.trim() : '';
+    const criteria = Array.isArray(spec.acceptanceCriteria) ? spec.acceptanceCriteria.filter((c) => typeof c === 'string' && c.trim()) : [];
+    return description === '' && criteria.length === 0;
+}
+/** True when the snapshot is an OUTLINE: ≥ the batch minimum of specs, none detailed. */
+function isOutlineSnapshot(raw) {
+    const specs = specList(raw);
+    if (!specs || specs.length < blueprint_types_1.M1_SPECS_MIN)
+        return false;
+    return specs.every(specIsEmpty);
+}
+/** Indices (0-based) of specs still without a body. */
+function unfilledSpecIndices(raw) {
+    const specs = specList(raw);
+    if (!specs)
+        return [];
+    return specs.flatMap((spec, index) => (specIsEmpty(spec) ? [index] : []));
+}
+/** Next detail range (0-based inclusive) or null when every spec is filled. */
+function nextDetailRange(raw, perTurn = exports.SPECS_PER_DETAIL_TURN) {
+    const pending = unfilledSpecIndices(raw);
+    if (pending.length === 0)
+        return null;
+    const from = pending[0];
+    const to = Math.min(from + perTurn - 1, pending[pending.length - 1]);
+    return { from, to };
+}
+/** Total projected turns for an outline of `total` specs (details + audit). */
+function projectedGenerationTurns(total, perTurn = exports.SPECS_PER_DETAIL_TURN) {
+    return 1 + Math.ceil(total / perTurn) + 1;
+}
+function specTitles(raw) {
+    return (specList(raw) ?? []).map((s) => (typeof s.title === 'string' ? s.title : ''));
+}
+// ─── Prompts (static apart from the range/titles, so the session cache holds) ─
+function buildDetailPrompt(range, titles) {
+    const items = [];
+    for (let i = range.from; i <= range.to; i++)
+        items.push(`- index ${i}: "${titles[i] ?? ''}"`);
+    return `APP CONTINUE: write the FULL premium detail for these outline specs now — every section, every sub-block, ${items.length === 1 ? 'the spec' : 'every spec'} at the depth the contract demands:
+${items.join('\n')}
+
+Reply with ONE fenced \`spec-detail\` block per spec and NOTHING else — no prose, no blueprint-draft block. Each block is strictly valid JSON:
+
+\`\`\`spec-detail
+{ "index": <the 0-based m1Specs index above>, "spec": { "kind": "...", "title": "...", "shortSummary": "...", "description": "...", "acceptanceCriteria": ["..."], "priority": "...", "labels": ["..."], "dependsOnIndex": <optional> } }
+\`\`\`
+
+Keep the index, kind, title, priority, labels and dependsOnIndex the outline already fixed (refine the title only if it was wrong). Newlines inside strings escaped as \\n, inner double quotes as \\", no trailing commas, no comments, no nested fences.`;
+}
+function buildAuditPrompt() {
+    return `APP AUDIT: every spec now has a body. Audit the WHOLE Milestone-1 batch against the contract — five headings once and in order, the ### sub-blocks, the section depth floors, ${exports.SPECS_PER_DETAIL_TURN}-spec consistency (titles unique, dependencies strictly backward, scaffold first), 6-10 criteria each with a failure case and an automated verification, English content, priority and labels. Reply with ONE fenced \`spec-audit\` block and NOTHING else:
+
+\`\`\`spec-audit
+{ "specsComplete": true, "issues": [], "fixes": [ { "index": <0-based>, "spec": { ...the complete corrected spec... } } ] }
+\`\`\`
+
+Put every spec you had to correct in \`fixes\` (complete spec objects, same shape as spec-detail). Set \`specsComplete\` to true only when every spec passes after your fixes; otherwise false with the blocking problems listed in \`issues\`.`;
+}
+function buildDetailRepairPrompt(range, titles, detail) {
+    const items = [];
+    for (let i = range.from; i <= range.to; i++)
+        items.push(`- index ${i}: "${titles[i] ?? ''}"`);
+    return `APP CHECK: your last reply did not yield usable spec-detail blocks for:
+${items.join('\n')}
+${detail ? `\nProblem: ${detail}\n` : ''}
+Re-emit ONE complete, strictly valid \`spec-detail\` block per spec above (index + complete spec object), and nothing else.`;
+}
+/** Correction turn after an audit that reported blocking problems (D7 §4). */
+function buildAuditIssuesPrompt(issues) {
+    const list = issues.map((i) => `- ${i}`).join('\n');
+    return `APP CHECK: your audit reported blocking problems. Fix EXACTLY these — enrich, never trim — and reply with ONE fenced \`spec-detail\` block per AFFECTED spec ({ "index": <0-based m1Specs index>, "spec": { …the complete corrected spec… } }) and nothing else; untouched specs keep their content.
+${list}`;
+}
+// ─── Fenced generation blocks ────────────────────────────────────────────────
+const DETAIL_FENCE_RE = /```spec-detail\s*\n([\s\S]*?)\n\s*```/g;
+const AUDIT_FENCE_RE = /```spec-audit\s*\n([\s\S]*?)\n\s*```/g;
+const OPEN_GENERATION_FENCE_RE = /```spec-(?:detail|audit)(?![\s\S]*?\n\s*```)/;
+function coerceDetail(value) {
+    const obj = record(value);
+    if (!obj)
+        return null;
+    const index = obj.index;
+    const spec = record(obj.spec);
+    if (typeof index !== 'number' || !Number.isInteger(index) || index < 0 || !spec)
+        return null;
+    return { index, spec };
+}
+/** Extract every closed spec-detail / spec-audit block; strip them from the text. */
+function parseGenerationBlocks(text) {
+    const out = { stripped: text ?? '', details: [], audit: null, rejected: [], truncated: false, hadBlocks: false };
+    if (!text || !/```spec-(?:detail|audit)/.test(text))
+        return out;
+    let stripped = '';
+    let cursor = 0;
+    const matches = [];
+    DETAIL_FENCE_RE.lastIndex = 0;
+    let m;
+    while ((m = DETAIL_FENCE_RE.exec(text)) !== null)
+        matches.push({ kind: 'detail', index: m.index, length: m[0].length, body: m[1] });
+    AUDIT_FENCE_RE.lastIndex = 0;
+    while ((m = AUDIT_FENCE_RE.exec(text)) !== null)
+        matches.push({ kind: 'audit', index: m.index, length: m[0].length, body: m[1] });
+    matches.sort((a, b) => a.index - b.index);
+    for (const block of matches) {
+        if (block.index < cursor)
+            continue; // overlapping match (nested fence quirk)
+        out.hadBlocks = true;
+        stripped += text.slice(cursor, block.index);
+        cursor = block.index + block.length;
+        const parsed = (0, json_tolerant_1.parseJsonTolerant)(block.body);
+        if (!parsed.ok) {
+            out.rejected.push(`${block.kind} block: ${parsed.error}${parsed.excerpt ? ` near …${parsed.excerpt}…` : ''}`);
+            continue;
+        }
+        if (block.kind === 'detail') {
+            const detail = coerceDetail(parsed.value);
+            if (!detail) {
+                out.rejected.push('spec-detail block: expected { "index": <integer>, "spec": { … } }');
+                continue;
+            }
+            out.details.push(detail);
+        }
+        else {
+            const obj = record(parsed.value);
+            if (!obj) {
+                out.rejected.push('spec-audit block: expected an object');
+                continue;
+            }
+            const fixes = Array.isArray(obj.fixes) ? obj.fixes.map(coerceDetail).filter((d) => d !== null) : [];
+            const issues = Array.isArray(obj.issues) ? obj.issues.filter((i) => typeof i === 'string') : [];
+            out.audit = { specsComplete: obj.specsComplete === true, issues, fixes };
+        }
+    }
+    const remainder = text.slice(cursor);
+    const open = OPEN_GENERATION_FENCE_RE.exec(remainder);
+    if (open) {
+        out.hadBlocks = true;
+        out.truncated = true;
+        out.rejected.push('a generation block was cut off before its closing fence');
+        stripped += remainder.slice(0, open.index);
+    }
+    else {
+        stripped += remainder;
+    }
+    out.stripped = stripped;
+    return out;
+}
+/** Merge spec-detail blocks into a raw snapshot by index (out-of-range ignored). */
+function mergeSpecDetails(raw, details) {
+    const source = record(raw);
+    if (!source || !Array.isArray(source.m1Specs))
+        return raw;
+    const specs = source.m1Specs.map((s) => (record(s) ? { ...s } : s));
+    for (const d of details) {
+        if (d.index >= specs.length)
+            continue;
+        const previous = record(specs[d.index]) ?? {};
+        // The outline fixed kind/title/priority/labels/dependency; a detail block
+        // may refine them but never DROP them (a missing key keeps the outline's).
+        specs[d.index] = { ...previous, ...d.spec };
+    }
+    return { ...source, m1Specs: specs };
+}
+function withSpecsComplete(raw, specsComplete) {
+    const source = record(raw);
+    if (!source)
+        return raw;
+    return { ...source, specsComplete };
+}
+/** True when every spec in `range` (0-based inclusive) now has a body. */
+function rangeFilled(raw, range) {
+    const specs = specList(raw);
+    if (!specs)
+        return false;
+    for (let i = range.from; i <= range.to; i++) {
+        const spec = specs[i];
+        if (!spec || specIsEmpty(spec))
+            return false;
+    }
+    return true;
+}
+/** Live-stream helper: cut an UNTERMINATED generation fence (mirrors the client). */
+function cutUnterminatedGenerationBlock(text) {
+    if (!text || !/```spec-(?:detail|audit)/.test(text))
+        return text ?? '';
+    const match = OPEN_GENERATION_FENCE_RE.exec(text);
+    if (!match)
+        return text;
+    return text.slice(0, match.index);
+}