Harden generated code cleanup

Co-authored-by: Codex <codex@openai.com>

app.py

@@ -274,12 +274,34 @@ def code_from_verdict(draft_code: str, verdict_json: str) -> str:
 
 def strip_markdown_code_fence(code: str) -> str:
     text = (code or "").strip()
-    fenced = re.fullmatch(r"```(?:[a-zA-Z0-9_+#.-]+)?\s*\n([\s\S]*?)\n?```", text)
-    if fenced:
-        return fenced.group(1).strip()
-    text = re.sub(r"^```(?:[a-zA-Z0-9_+#.-]+)?\s*", "", text)
-    text = re.sub(r"\s*```$", "", text)
-    return text.strip()
+    if not text:
+        return ""
+
+    opening_fence = re.match(r"^```(?:[a-zA-Z0-9_+#.-]+)?\s*\n?", text)
+    if opening_fence:
+        text = text[opening_fence.end() :]
+        closing_index = text.find("```")
+        if closing_index >= 0:
+            text = text[:closing_index]
+    else:
+        first_fence = text.find("```")
+        if first_fence >= 0:
+            text = text[:first_fence]
+
+    return trim_markdown_explanation(text)
+
+
+def trim_markdown_explanation(text: str) -> str:
+    explanation = re.compile(
+        r"^\s*(?:[-*]\s+|\d+\.\s+|#{1,6}\s+|Explanation\s*:|Steps\s*:|Notes?\s*:|The code\b|This code\b)",
+        re.IGNORECASE,
+    )
+    kept = []
+    for line in text.splitlines():
+        if explanation.match(line):
+            break
+        kept.append(line)
+    return "\n".join(kept).strip()
 
 
 async def run_sandbox(language: str, draft_code: str, verdict_json: str) -> str:

static/engine.js

@@ -37,9 +37,19 @@ export async function generateCode(prompt, language, onToken, onComplete) {
     const messages = [
         {
             role: "system",
-            content: `You are an expert ${language} programmer. Write clean, correct, production-ready code. Output only code, with no markdown or explanation.`,
+            content: [
+                `You are an expert ${language} programmer.`,
+                "Return raw source code only.",
+                "Do not use markdown fences.",
+                "Do not add explanations, bullet points, headings, comments, or usage notes.",
+                "Do not wrap the answer in ```.",
+                "The response must be directly executable or pasteable as a source file.",
+            ].join(" "),
+        },
+        {
+            role: "user",
+            content: `${prompt}\n\nReturn only the ${language} code. No markdown. No comments. No explanation.`,
         },
-        { role: "user", content: prompt },
     ];
 
     const streamer = new TextStreamer(generator.tokenizer, {
@@ -84,9 +94,36 @@ function formatError(error) {
 
 export function stripMarkdownCodeFence(text) {
     const trimmed = String(text || "").trim();
-    const match = trimmed.match(/^```(?:[a-zA-Z0-9_+#.-]+)?\s*\n([\s\S]*?)\n?```$/);
-    if (match) return match[1].trim();
-    return trimmed.replace(/^```(?:[a-zA-Z0-9_+#.-]+)?\s*/, "").replace(/\s*```$/, "").trim();
+    if (!trimmed) return "";
+
+    let code = trimmed;
+    const openingFence = code.match(/^```(?:[a-zA-Z0-9_+#.-]+)?\s*\n?/);
+    if (openingFence) {
+        code = code.slice(openingFence[0].length);
+        const closingIndex = code.indexOf("```");
+        if (closingIndex >= 0) code = code.slice(0, closingIndex);
+    } else {
+        const firstFence = code.indexOf("```");
+        if (firstFence >= 0) code = code.slice(0, firstFence);
+    }
+
+    return trimMarkdownExplanation(code);
+}
+
+function trimMarkdownExplanation(text) {
+    const lines = String(text || "").split(/\r?\n/);
+    const explanationPattern =
+        /^\s*(?:[-*]\s+|\d+\.\s+|#{1,6}\s+|Explanation\s*:|Steps\s*:|Notes?\s*:|The code\b|This code\b)/i;
+
+    let cutIndex = lines.length;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (explanationPattern.test(lines[i])) {
+            cutIndex = i;
+            break;
+        }
+    }
+
+    return lines.slice(0, cutIndex).join("\n").trim();
 }
 
 Object.assign(window, {