Auto-correct EVERY broken GDScript block in place (capped at MAX_FIX_PASSES)

respond() now repairs each broken fenced block instead of only the first:
- validate.gdscript_block_spans() locates every block with its span;
first_gdscript_block() pulls the corrected code out of each fix pass.
- _autocorrect() walks the blocks, regenerates a fix for each broken one
(one GPU call each), and splices the corrected code back IN PLACE of the
original (only if the fix actually parses), preserving surrounding prose.
- Capped at MAX_FIX_PASSES (3) GPU calls per answer so a pathological answer
with many broken blocks can't blow the GPU budget; the report notes how
many were fixed / left.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

app.py

@@ -29,6 +29,11 @@ import prompt as promptlib
 import generate as gen
 import validate as gdv
 
+# Cap on auto-correction GPU calls per answer. Each broken block fixed is one
+# extra gen.generate() (one @spaces.GPU call), so this bounds the total GPU
+# work a single pathological answer (many broken blocks) can trigger.
+MAX_FIX_PASSES = 3
+
 
 def _sources_md(hits: list[rag.Hit]) -> str:
     if not hits:
@@ -43,6 +48,36 @@ def _sources_md(hits: list[rag.Hit]) -> str:
     return "\n".join(lines)
 
 
+def _autocorrect(answer: str) -> tuple[str, int, int]:
+    """Repair each broken ```gdscript block IN PLACE, fixing at most
+    MAX_FIX_PASSES of them (one GPU call each). Returns
+    (new_answer, num_fixed, num_broken). num_broken counts every block that
+    failed to parse (including any beyond the cap, so the caller can report
+    how many were left)."""
+    spans = gdv.gdscript_block_spans(answer)
+    pieces: list[str] = []
+    cursor = num_fixed = num_broken = passes = 0
+    for code, start, end in spans:
+        pieces.append(answer[cursor:start])
+        block_text = answer[start:end]            # the whole ```...``` fence
+        res = gdv.validate_code(code)
+        if not res.ok:
+            num_broken += 1
+            if passes < MAX_FIX_PASSES:
+                passes += 1
+                fix_out = gen.generate(promptlib.build_fix_messages(code, res.error))
+                fix_code = gdv.first_gdscript_block(fix_out)
+                # Only splice in a fix that actually parses; otherwise keep the
+                # original (it stays flagged ❌ in the validation report).
+                if fix_code and gdv.validate_code(fix_code).ok:
+                    block_text = f"```gdscript\n{fix_code}\n```"
+                    num_fixed += 1
+        pieces.append(block_text)
+        cursor = end
+    pieces.append(answer[cursor:])
+    return "".join(pieces), num_fixed, num_broken
+
+
 def respond(message: str, history, top_k: int, self_correct: bool,
             history_turns: int = promptlib.MAX_HISTORY_TURNS):
     message = (message or "").strip()
@@ -54,28 +89,26 @@ def respond(message: str, history, top_k: int, self_correct: bool,
                                         max_turns=int(history_turns))
     answer = gen.generate(messages)
 
-    results = gdv.validate_answer(answer)
-
-    # One optional self-correction pass if a code block failed to parse.
+    # Self-correction: repair EVERY broken GDScript block in place, capped at
+    # MAX_FIX_PASSES GPU calls so a pathological answer can't blow the budget.
+    fix_note = ""
     if self_correct:
-        fail = gdv.first_syntax_error(results)
-        if fail is not None:
-            broken, err = fail
-            fixed = gen.generate(promptlib.build_fix_messages(broken, err))
-            fixed_results = gdv.validate_answer(fixed)
-            if fixed_results and all(r.ok for r in fixed_results):
-                answer = (answer
-                          + "\n\n---\n**🔧 Auto-corrected** (original had a syntax "
-                            "error):\n\n" + fixed)
-                results = fixed_results
+        answer, n_fixed, n_broken = _autocorrect(answer)
+        if n_broken:
+            head = f"🔧 Auto-corrected {n_fixed}/{n_broken} broken block(s) in place"
+            if n_broken > MAX_FIX_PASSES:
+                head += f" — capped at {MAX_FIX_PASSES} fix passes, " \
+                        f"{n_broken - MAX_FIX_PASSES} not attempted"
+            fix_note = f"\n\n**{head}.**"
 
+    results = gdv.validate_answer(answer)
     report = gdv.render_report(results)
     note = ("" if rag.index_available()
             else "\n\n> ⏳ _Retrieval index not loaded yet — answering without "
                  "corpus context. Build & push the index (see DEPLOY.md)._")
     # The VALIDATION_DELIM prefix lets prompt._clean_assistant strip this
     # decoration when the turn is fed back as multi-turn history.
-    return (f"{answer}{promptlib.VALIDATION_DELIM} \n{report}"
+    return (f"{answer}{promptlib.VALIDATION_DELIM} \n{report}{fix_note}"
             f"{_sources_md(hits)}{note}")
 
 

validate.py

@@ -100,6 +100,25 @@ def validate_answer(answer: str) -> list[BlockResult]:
     return [validate_code(b) for b in extract_gdscript_blocks(answer)]
 
 
+def gdscript_block_spans(text: str) -> list[tuple[str, int, int]]:
+    """Each fenced GDScript block as (stripped_code, match_start, match_end), in
+    document order. The span covers the whole ```...``` fence so a caller can
+    splice a corrected block back in place of the original."""
+    out: list[tuple[str, int, int]] = []
+    for m in _FENCE_RE.finditer(text or ""):
+        code = m.group(1).strip()
+        if code:
+            out.append((code, m.start(), m.end()))
+    return out
+
+
+def first_gdscript_block(text: str) -> str:
+    """First fenced GDScript block (stripped), or '' if none — used to pull the
+    corrected code out of a fix generation."""
+    blocks = extract_gdscript_blocks(text)
+    return blocks[0] if blocks else ""
+
+
 def render_report(results: list[BlockResult]) -> str:
     """Markdown summary for the UI."""
     if not results: