Spaces:

sanjuhs
/

cadforge-cadquery-openenv

Running

App Files Files Community

sanjuhs commited on 15 days ago

Commit

5fa6fc8

verified ·

1 Parent(s): f6a99e5

Add rendered blog diagrams and Colab-safe notebook

Browse files

Files changed (7) hide show

docs/detailed-blog/cadforge-detailed-blog.md +9 -0
docs/detailed-blog/rendered-assets/adaptive-repair-loop-rendered.png +0 -0
docs/detailed-blog/rendered-assets/environment-loop-rendered.png +0 -0
docs/detailed-blog/rendered-assets/reference-generation-loop-rendered.png +0 -0
docs/detailed-blog/rendered-assets/self-improvement-loop-summary.png +0 -0
src/main.js +8 -0
training/cadforge_openenv_training_colab.ipynb +520 -494

docs/detailed-blog/cadforge-detailed-blog.md CHANGED Viewed

@@ -105,6 +105,8 @@ flowchart TD
   H --> B
 ```
 Every episode can write:
 - generated CadQuery code,
@@ -234,6 +236,8 @@ flowchart TD
   J --> A
 ```
 This is the environment "fighting back." If the model keeps clipping code before `fixture`, the next batch includes more syntax-closure repairs. If it invents APIs, the next batch asks it to rewrite using conservative primitives. If it builds but misses semantics, the next batch asks for named subassemblies and recognizable features.
 The adaptive curriculum generator produced a 180-row repair set from 320 strict GRPO rollouts. It found:
@@ -274,6 +278,8 @@ flowchart LR
   J --> K
 ```
 This is the scalable route. A human does not need to hand-design every CAD target. The pipeline can generate many task prompts, create reference images, turn them into GLBs, extract similarity signals, and train models to write editable CadQuery that approximates the object.
 The wedge is important:
@@ -510,6 +516,9 @@ All must-have visuals are now present locally in `docs/detailed-blog/rendered-as
 | GLB reference beside generated CadQuery render | present |
 | compact build-rate chart | present |
 | adaptive curriculum failure-class chart | present |
 | self-improvement loop summary | present |
 The only additional images that would make the case stronger are:

   H --> B
 ```
+![Rendered CADForge environment loop](./rendered-assets/environment-loop-rendered.png)
 Every episode can write:
 - generated CadQuery code,
   J --> A
 ```
+![Rendered adaptive repair curriculum loop](./rendered-assets/adaptive-repair-loop-rendered.png)
 This is the environment "fighting back." If the model keeps clipping code before `fixture`, the next batch includes more syntax-closure repairs. If it invents APIs, the next batch asks it to rewrite using conservative primitives. If it builds but misses semantics, the next batch asks for named subassemblies and recognizable features.
 The adaptive curriculum generator produced a 180-row repair set from 320 strict GRPO rollouts. It found:
   J --> K
 ```
+![Rendered prompt-image-GLB reference loop](./rendered-assets/reference-generation-loop-rendered.png)
 This is the scalable route. A human does not need to hand-design every CAD target. The pipeline can generate many task prompts, create reference images, turn them into GLBs, extract similarity signals, and train models to write editable CadQuery that approximates the object.
 The wedge is important:
 | GLB reference beside generated CadQuery render | present |
 | compact build-rate chart | present |
 | adaptive curriculum failure-class chart | present |
+| rendered environment loop diagram | present |
+| rendered adaptive repair loop diagram | present |
+| rendered prompt-image-GLB loop diagram | present |
 | self-improvement loop summary | present |
 The only additional images that would make the case stronger are:

docs/detailed-blog/rendered-assets/adaptive-repair-loop-rendered.png ADDED Viewed

docs/detailed-blog/rendered-assets/environment-loop-rendered.png ADDED Viewed

docs/detailed-blog/rendered-assets/reference-generation-loop-rendered.png ADDED Viewed

docs/detailed-blog/rendered-assets/self-improvement-loop-summary.png CHANGED Viewed

src/main.js CHANGED Viewed

@@ -7,6 +7,8 @@ import { renderScadToGroup } from "./scadRenderer.js";
 const app = document.querySelector("#app");
 const route = window.location.pathname;
 const isLandingPage = route === "/" || route === "/index.html";
 const isCadQueryGeneratorPage = route === "/cadquery";
 const isCadQueryRendererPage = route === "/cadquery-renderer";
@@ -41,6 +43,11 @@ app.innerHTML = `
           <strong>Reward environment</strong>
           <small>Generate, revise, render, and score Markus-chair CadQuery candidates against the ideal code and GLB reference.</small>
         </a>
       </div>
     </section>
   </main>
@@ -53,6 +60,7 @@ app.innerHTML = `
         <a class="${isCadQueryGeneratorPage ? "active" : ""}" href="/cadquery">CadQuery</a>
         <a class="${isCadQueryRendererPage ? "active" : ""}" href="/cadquery-renderer">Renderer</a>
         <a class="${isCadQueryEnvPage ? "active" : ""}" href="/cadquery-env">Env</a>
       </nav>
       <div>
         <p class="eyebrow">CADForge Experiment 2</p>

 const app = document.querySelector("#app");
 const route = window.location.pathname;
+const detailedBlogUrl =
+  "https://huggingface.co/spaces/sanjuhs/cadforge-cadquery-openenv/blob/main/docs/detailed-blog/cadforge-detailed-blog.md";
 const isLandingPage = route === "/" || route === "/index.html";
 const isCadQueryGeneratorPage = route === "/cadquery";
 const isCadQueryRendererPage = route === "/cadquery-renderer";
           <strong>Reward environment</strong>
           <small>Generate, revise, render, and score Markus-chair CadQuery candidates against the ideal code and GLB reference.</small>
         </a>
+        <a class="route-card" href="${detailedBlogUrl}" target="_blank" rel="noreferrer">
+          <span>Submission</span>
+          <strong>Detailed blog</strong>
+          <small>Read the full hackathon story: frontier model failures, reward design, SFT/GRPO evidence, and self-improvement loops.</small>
+        </a>
       </div>
     </section>
   </main>
         <a class="${isCadQueryGeneratorPage ? "active" : ""}" href="/cadquery">CadQuery</a>
         <a class="${isCadQueryRendererPage ? "active" : ""}" href="/cadquery-renderer">Renderer</a>
         <a class="${isCadQueryEnvPage ? "active" : ""}" href="/cadquery-env">Env</a>
+        <a href="${detailedBlogUrl}" target="_blank" rel="noreferrer">Detailed Blog</a>
       </nav>
       <div>
         <p class="eyebrow">CADForge Experiment 2</p>

training/cadforge_openenv_training_colab.ipynb CHANGED Viewed

@@ -1,496 +1,522 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# CADForge OpenEnv Training Run Notebook\n",
-        "\n",
-        "[Open this notebook in Google Colab](https://colab.research.google.com/github/sanjuhs/open-env-meta-final-hackathon/blob/main/training/cadforge_openenv_training_colab.ipynb) | [Notebook in the HF Space repo](https://huggingface.co/spaces/sanjuhs/cadforge-cadquery-openenv/blob/main/training/cadforge_openenv_training_colab.ipynb)\n",
-        "\n",
-        "This is the public, judge-runnable training notebook for CADForge. It is intentionally split into two parts:\n",
-        "\n",
-        "1. **Colab smoke run**: runs a tiny 3-step SFT training job and validates the CADForge reward pipeline so judges can verify the code path without renting an H200.\n",
-        "2. **Production run evidence**: links to the exact scripts, reports, model adapters, dataset, and full H200 commands used for the submitted runs.\n",
-        "\n",
-        "The final submitted models were trained outside Colab on a RunPod H200 because Qwen3.5 9B + CADForge GRPO is too large for free Colab. The notebook does not pretend to rerun the full job; it proves the same training scripts and public dataset execute end-to-end on a tiny sample."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## What judges should check\n",
-        "\n",
-        "- The repo clone and dependency install succeed.\n",
-        "- The OpenEnv app validates.\n",
-        "- The public HF dataset loads.\n",
-        "- The CADForge reward smoke test compiles and scores real CadQuery.\n",
-        "- The 3-step SFT smoke run calls `training/train_sft_unsloth.py`, the same script used for the production SFT runs.\n",
-        "- The optional GRPO cell calls `training/train_grpo_cadforge.py`, the same script used for strict build-gated GRPO.\n",
-        "- The final report cells show the committed metrics and generated artifacts from the full H200 training run."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Public artifacts\n",
-        "\n",
-        "- Project repo: https://github.com/sanjuhs/open-env-meta-final-hackathon\n",
-        "- Hugging Face Space repo: https://huggingface.co/spaces/sanjuhs/cadforge-cadquery-openenv\n",
-        "- Training dataset: https://huggingface.co/datasets/sanjuhs/cadforge-cadquery-agentic-traces\n",
-        "- 2B SFT adapter: https://huggingface.co/sanjuhs/qwen35-2b-cadforge-sft-lora\n",
-        "- 2B GRPO adapter: https://huggingface.co/sanjuhs/qwen35-2b-cadforge-grpo-lora\n",
-        "- 9B SFT adapter: https://huggingface.co/sanjuhs/qwen35-9b-cadforge-sft-lora\n",
-        "- 9B GRPO adapter: https://huggingface.co/sanjuhs/qwen35-9b-cadforge-grpo-lora\n",
-        "- 9B strict build-gated GRPO adapter: https://huggingface.co/sanjuhs/qwen35-9b-cadforge-grpo-strict-build-lora"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 1. Configure\n",
-        "\n",
-        "For a normal judge rerun, keep `RUN_SFT_SMOKE = True` and `RUN_GRPO_CADFORGE_SMOKE = False`.\n",
-        "\n",
-        "The SFT smoke is the best Colab-friendly proof that the training script is real. The CADForge reward smoke separately proves that the OpenEnv/CadQuery reward backend is real. GRPO is left optional because even a tiny CADForge GRPO run can be slow or memory-heavy on Colab T4/L4 runtimes."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "from pathlib import Path\n",
-        "\n",
-        "REPO_URL = \"https://github.com/sanjuhs/open-env-meta-final-hackathon.git\"\n",
-        "REPO_DIR = Path(\"/content/open-env-meta-final-hackathon\")\n",
-        "\n",
-        "# Public dataset produced for CADForge.\n",
-        "DATASET = \"sanjuhs/cadforge-cadquery-agentic-traces\"\n",
-        "\n",
-        "# Keep these small for public judge reruns.\n",
-        "RUN_SFT_SMOKE = True\n",
-        "RUN_GRPO_CADFORGE_SMOKE = False\n",
-        "SFT_SMOKE_STEPS = 3\n",
-        "\n",
-        "# Make the flags visible to %%bash cells.\n",
-        "os.environ[\"RUN_SFT_SMOKE\"] = \"1\" if RUN_SFT_SMOKE else \"0\"\n",
-        "os.environ[\"RUN_GRPO_CADFORGE_SMOKE\"] = \"1\" if RUN_GRPO_CADFORGE_SMOKE else \"0\"\n",
-        "\n",
-        "# Optional. Only needed if you want to push adapters or access private repos.\n",
-        "os.environ.setdefault(\"HF_TOKEN\", \"\")\n",
-        "\n",
-        "BASE_2B = \"unsloth/Qwen3.5-2B\"\n",
-        "BASE_9B = \"unsloth/Qwen3.5-9B\"\n",
-        "print(\"Configured notebook smoke run\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 2. Clone and install\n",
-        "\n",
-        "This uses `uv` to match the production RunPod environment. The install can take several minutes on a fresh Colab runtime."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%bash\n",
-        "set -euo pipefail\n",
-        "\n",
-        "if [ ! -d /content/open-env-meta-final-hackathon/.git ]; then\n",
-        "  rm -rf /content/open-env-meta-final-hackathon\n",
-        "  git clone --depth 1 https://github.com/sanjuhs/open-env-meta-final-hackathon.git /content/open-env-meta-final-hackathon\n",
-        "else\n",
-        "  cd /content/open-env-meta-final-hackathon\n",
-        "  git fetch --depth 1 origin main\n",
-        "  git reset --hard origin/main\n",
-        "fi\n",
-        "\n",
-        "cd /content/open-env-meta-final-hackathon\n",
-        "curl -LsSf https://astral.sh/uv/install.sh | sh || true\n",
-        "export PATH=\"$HOME/.local/bin:$PATH\"\n",
-        "\n",
-        "export UV_CACHE_DIR=/content/.uv-cache\n",
-        "export HF_HOME=/content/.cache/huggingface\n",
-        "export TORCH_HOME=/content/.cache/torch\n",
-        "export TRITON_CACHE_DIR=/content/.cache/triton\n",
-        "export VLLM_CACHE_ROOT=/content/.cache/vllm\n",
-        "export UV_LINK_MODE=copy\n",
-        "export HF_HUB_ENABLE_HF_TRANSFER=1\n",
-        "export HF_HUB_DISABLE_XET=1\n",
-        "\n",
-        "uv sync --project experiment-2-cadforge\n",
-        "uv run --project experiment-2-cadforge python - <<'PY'\n",
-        "import numpy, trimesh, scipy, cadquery\n",
-        "print('CADForge project env OK:', numpy.__version__)\n",
-        "PY\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 3. Validate the OpenEnv submission and inline reward backend\n",
-        "\n",
-        "This validates the OpenEnv app, then evaluates a small pasted CadQuery program through the real CADForge reward environment.\n",
-        "\n",
-        "The old root-level smoke command is kept as comments inside the cell because it can fail in Colab when `cadquery_env.py` runs outside the `experiment-2-cadforge` virtualenv. The working path is `uv run --project experiment-2-cadforge ...`, which gives the reward code access to `numpy`, `trimesh`, `scipy`, and `cadquery`.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%bash\n",
-        "set -euo pipefail\n",
-        "cd /content/open-env-meta-final-hackathon\n",
-        "export PATH=\"$HOME/.local/bin:$PATH\"\n",
-        "\n",
-        "uv run --project experiment-2-cadforge openenv validate experiment-2-cadforge\n",
-        "\n",
-        "# Kept for reference only. In Colab this can run from the root uv env and miss\n",
-        "# numpy/cadquery/trimesh, which causes ModuleNotFoundError inside cadquery_env.py.\n",
-        "# uv run training/smoke_cadforge_reward.py --reward-mode fast\n",
-        "\n",
-        "cat > /tmp/cadforge_inline_candidate.py <<'CANDIDATEPY'\n",
-        "import cadquery as cq\n",
-        "\n",
-        "# Tiny editable wall-mounted J-hook for the notebook smoke test.\n",
-        "# This is deliberately simple so judges can verify the CADForge reward path quickly.\n",
-        "plate_w = 46.0\n",
-        "plate_h = 72.0\n",
-        "plate_t = 6.0\n",
-        "hook_len = 58.0\n",
-        "hook_t = 12.0\n",
-        "hook_drop = 34.0\n",
-        "rib_t = 8.0\n",
-        "hole_d = 6.0\n",
-        "\n",
-        "plate = cq.Workplane(\"XY\").box(plate_w, plate_t, plate_h).translate((0, 0, plate_h / 2.0))\n",
-        "\n",
-        "upper_hole = (\n",
-        "    cq.Workplane(\"XY\")\n",
-        "    .circle(hole_d / 2.0)\n",
-        "    .extrude(plate_t + 2.0)\n",
-        "    .translate((0, -1.0, plate_h * 0.72))\n",
-        ")\n",
-        "lower_hole = (\n",
-        "    cq.Workplane(\"XY\")\n",
-        "    .circle(hole_d / 2.0)\n",
-        "    .extrude(plate_t + 2.0)\n",
-        "    .translate((0, -1.0, plate_h * 0.28))\n",
-        ")\n",
-        "plate = plate.cut(upper_hole).cut(lower_hole)\n",
-        "\n",
-        "arm = cq.Workplane(\"XY\").box(hook_len, hook_t, hook_t).translate((hook_len / 2.0, 0, plate_h * 0.52))\n",
-        "tip = cq.Workplane(\"XY\").box(hook_t, hook_t, hook_drop).translate((hook_len, 0, plate_h * 0.52 - hook_drop / 2.0))\n",
-        "rib = cq.Workplane(\"XY\").box(hook_len * 0.65, rib_t, rib_t).translate((hook_len * 0.33, 0, plate_h * 0.38))\n",
-        "\n",
-        "fixture = plate.union(arm).union(tip).union(rib).clean()\n",
-        "CANDIDATEPY\n",
-        "\n",
-        "uv run --project experiment-2-cadforge python \\\n",
-        "  experiment-2-cadforge/python_tools/cadquery_env.py evaluate \\\n",
-        "  --code-file /tmp/cadforge_inline_candidate.py \\\n",
-        "  --episode-id notebook-inline-smoke \\\n",
-        "  --step-id pasted-cadquery-candidate \\\n",
-        "  --task-spec wall_j_hook_120n \\\n",
-        "  --task-prompt \"Design a simple editable wall mounted J hook with a wall plate, hook arm, support rib, and screw holes.\" \\\n",
-        "  --reward-mode fast\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 4. Inspect the public training data\n",
-        "\n",
-        "The production scripts download from the same public Hugging Face dataset if local JSONL files are absent."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%bash\n",
-        "set -euo pipefail\n",
-        "cd /content/open-env-meta-final-hackathon\n",
-        "export PATH=\"$HOME/.local/bin:$PATH\"\n",
-        "\n",
-        "uv run --with datasets --with huggingface_hub python - <<'PY'\n",
-        "from datasets import load_dataset\n",
-        "\n",
-        "repo = \"sanjuhs/cadforge-cadquery-agentic-traces\"\n",
-        "files = {\n",
-        "    \"sft_train\": \"data/sft/prompt_to_cadquery_train.jsonl\",\n",
-        "    \"repair_train\": \"data/repair/cadquery_repair_train.jsonl\",\n",
-        "    \"rl_rollouts\": \"data/rl/cadquery_rollouts.jsonl\",\n",
-        "}\n",
-        "for name, path in files.items():\n",
-        "    ds = load_dataset(\"json\", data_files={name: f\"hf://datasets/{repo}/{path}\"}, split=name)\n",
-        "    print(name, len(ds), list(ds[0].keys()))\n",
-        "PY"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 5. Three-step SFT smoke training\n",
-        "\n",
-        "This runs the same SFT script used for the full runs, but with a tiny row limit and 3 optimizer steps. It is the Colab-friendly proof of the training entrypoint.\n",
-        "\n",
-        "The production SFT runs used longer schedules and larger context on RunPod H200. Those commands and reports are shown below."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%bash\n",
-        "set -euo pipefail\n",
-        "cd /content/open-env-meta-final-hackathon\n",
-        "export PATH=\"$HOME/.local/bin:$PATH\"\n",
-        "export HF_HUB_DISABLE_XET=1\n",
-        "\n",
-        "if [ \"${RUN_SFT_SMOKE:-1}\" != \"1\" ]; then\n",
-        "  echo \"SFT smoke disabled in config.\"\n",
-        "  exit 0\n",
-        "fi\n",
-        "\n",
-        "CUDA_READY=$(python - <<'PY'\n",
-        "import torch\n",
-        "print('1' if torch.cuda.is_available() else '0')\n",
-        "PY\n",
-        ")\n",
-        "echo \"CUDA available: $CUDA_READY\"\n",
-        "if [ \"$CUDA_READY\" != \"1\" ]; then\n",
-        "  echo \"Skipping SFT smoke: switch Colab runtime to GPU, then rerun this cell.\"\n",
-        "  exit 0\n",
-        "fi\n",
-        "\n",
-        "uv run training/train_sft_unsloth.py \\\n",
-        "  --model unsloth/Qwen3.5-2B \\\n",
-        "  --output-dir outputs/notebook-qwen35-2b-cadforge-sft-3step \\\n",
-        "  --max-steps 3 \\\n",
-        "  --limit-train-rows 12 \\\n",
-        "  --limit-val-rows 4 \\\n",
-        "  --max-seq-length 2048 \\\n",
-        "  --per-device-train-batch-size 1 \\\n",
-        "  --gradient-accumulation-steps 1 \\\n",
-        "  --eval-steps 3 \\\n",
-        "  --save-steps 3 \\\n",
-        "  --lora-r 16 \\\n",
-        "  --lora-alpha 32 \\\n",
-        "  --load-in-4bit \\\n",
-        "  --run-name notebook-qwen35-2b-sft-3step"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 6. Optional 3-step GRPO smoke\n",
-        "\n",
-        "This calls the actual GRPO training script with strict build gating and the real CADForge reward backend. Leave it disabled for quick judging; enable it only on a strong GPU runtime."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "if not RUN_GRPO_CADFORGE_SMOKE:\n",
-        "    print(\"GRPO CADForge smoke disabled by default. Set RUN_GRPO_CADFORGE_SMOKE = True in the config cell to run it.\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%bash\n",
-        "set -euo pipefail\n",
-        "cd /content/open-env-meta-final-hackathon\n",
-        "export PATH=\"$HOME/.local/bin:$PATH\"\n",
-        "export HF_HUB_DISABLE_XET=1\n",
-        "export CADFORGE_PYTHON=/content/open-env-meta-final-hackathon/experiment-2-cadforge/.venv/bin/python\n",
-        "\n",
-        "GRPO_READY=$(python - <<'PY'\n",
-        "import os, torch\n",
-        "run = os.environ.get('RUN_GRPO_CADFORGE_SMOKE', '').lower() in {'1', 'true', 'yes'}\n",
-        "print('1' if run and torch.cuda.is_available() else '0')\n",
-        "PY\n",
-        ")\n",
-        "echo \"GRPO ready: $GRPO_READY\"\n",
-        "if [ \"$GRPO_READY\" != \"1\" ]; then\n",
-        "  echo \"Skipping optional GRPO smoke. Change RUN_GRPO_CADFORGE_SMOKE=1 in this cell and use a GPU runtime to run it.\"\n",
-        "  exit 0\n",
-        "fi\n",
-        "\n",
-        "uv run training/train_grpo_cadforge.py \\\n",
-        "  --model unsloth/Qwen3.5-2B \\\n",
-        "  --adapter outputs/notebook-qwen35-2b-cadforge-sft-3step \\\n",
-        "  --output-dir outputs/notebook-qwen35-2b-cadforge-grpo-3step \\\n",
-        "  --reward-backend cadforge \\\n",
-        "  --strict-build-gate \\\n",
-        "  --cadforge-python \"$CADFORGE_PYTHON\" \\\n",
-        "  --cadforge-reward-mode fast \\\n",
-        "  --limit-prompts 2 \\\n",
-        "  --max-steps 3 \\\n",
-        "  --num-generations 2 \\\n",
-        "  --max-prompt-length 2048 \\\n",
-        "  --max-completion-length 1024 \\\n",
-        "  --max-seq-length 4096 \\\n",
-        "  --per-device-train-batch-size 2 \\\n",
-        "  --gradient-accumulation-steps 1 \\\n",
-        "  --learning-rate 5e-6 \\\n",
-        "  --debug-completions-jsonl training/logs/notebook-grpo-3step-completions.jsonl \\\n",
-        "  --run-name notebook-qwen35-2b-grpo-3step"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 7. Exact production scripts\n",
-        "\n",
-        "The full submitted run used the scripts below, not notebook-only code:\n",
-        "\n",
-        "- `training/train_sft_unsloth.py`\n",
-        "- `training/train_grpo_cadforge.py`\n",
-        "- `training/evaluate_cadforge_model.py`\n",
-        "- `training/make_training_report.py`\n",
-        "- `training/cadforge_training_pipeline.sh`\n",
-        "- `training/run_strict_9b_grpo.sh`\n",
-        "\n",
-        "The final strict GRPO run used build gating: failed CAD builds received negative reward, while successful builds unlocked dense topology, semantic, reference, and editability rewards."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "%%bash\n",
-        "set -euo pipefail\n",
-        "cd /content/open-env-meta-final-hackathon\n",
-        "export PATH=\"$HOME/.local/bin:$PATH\"\n",
-        "\n",
-        "printf '\\n--- SFT script CLI ---\\n'\n",
-        "uv run training/train_sft_unsloth.py --help | sed -n '1,120p'\n",
-        "\n",
-        "printf '\\n--- GRPO script CLI ---\\n'\n",
-        "uv run training/train_grpo_cadforge.py --help | sed -n '1,180p'\n",
-        "\n",
-        "printf '\\n--- Strict 9B production wrapper ---\\n'\n",
-        "sed -n '1,220p' training/run_strict_9b_grpo.sh"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 8. Production run evidence\n",
-        "\n",
-        "These reports are committed in the public repo and mirrored in the Hugging Face Space repo. They are the evidence for the real H200 training run."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from IPython.display import Image, Markdown, display\n",
-        "from pathlib import Path\n",
-        "\n",
-        "repo = Path('/content/open-env-meta-final-hackathon')\n",
-        "report_dir = repo / 'training/reports/qwen35-9b-grpo-strict-build-20260426-strict-build'\n",
-        "\n",
-        "for image_name in ['grpo_reward_curve.png', 'grpo_code_health.png', 'grpo_error_breakdown.png']:\n",
-        "    path = report_dir / image_name\n",
-        "    if path.exists():\n",
-        "        display(Markdown(f'### {image_name}'))\n",
-        "        display(Image(filename=str(path)))\n",
-        "    else:\n",
-        "        print('Missing', path)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from IPython.display import Markdown, display\n",
-        "from pathlib import Path\n",
-        "\n",
-        "repo = Path('/content/open-env-meta-final-hackathon')\n",
-        "for rel in [\n",
-        "    'training/RUNPOD_SMOKE_REPORT.md',\n",
-        "    'training/reports/qwen35-9b-grpo-strict-build-20260426-strict-build/training_curve_report.md',\n",
-        "    'training/eval/qwen35-9b-cadforge-grpo-strict-build-20260426-strict-build/eval_report.md',\n",
-        "]:\n",
-        "    path = repo / rel\n",
-        "    display(Markdown(f'## {rel}'))\n",
-        "    if path.exists():\n",
-        "        display(Markdown(path.read_text()))\n",
-        "    else:\n",
-        "        print('Missing', path)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## 9. Summary of the submitted training run\n",
-        "\n",
-        "- Qwen3.5-2B SFT: train loss `1.4480 -> 0.1658`, eval loss `0.4477 -> 0.2676`.\n",
-        "- Qwen3.5-9B SFT: train loss `2.6020 -> 0.1413`, eval loss `0.3650 -> 0.2398`.\n",
-        "- Qwen3.5-9B strict GRPO: `320` completions, `96` buildable completions, best CADForge score `0.9352`.\n",
-        "- Quick held-out eval after strict GRPO: `2/3` prompts built successfully.\n",
-        "\n",
-        "The 3-step Colab run above is a reproducibility smoke test. The linked reports and adapters are the full training artifacts."
-      ]
-    }
-  ],
-  "metadata": {
-    "accelerator": "GPU",
-    "colab": {
-      "include_colab_link": true,
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "name": "python",
-      "version": "3.x"
-    }
   },
-  "nbformat": 4,
-  "nbformat_minor": 5
-}

 {
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CADForge OpenEnv Training Run Notebook\n",
+    "\n",
+    "[Open this notebook in Google Colab](https://colab.research.google.com/github/sanjuhs/open-env-meta-final-hackathon/blob/main/training/cadforge_openenv_training_colab.ipynb) | [Notebook in the HF Space repo](https://huggingface.co/spaces/sanjuhs/cadforge-cadquery-openenv/blob/main/training/cadforge_openenv_training_colab.ipynb)\n",
+    "\n",
+    "This is the public, judge-runnable training notebook for CADForge. It is intentionally split into two parts:\n",
+    "\n",
+    "1. **Colab smoke run**: runs a tiny 3-step SFT training job and validates the CADForge reward pipeline so judges can verify the code path without renting an H200.\n",
+    "2. **Production run evidence**: links to the exact scripts, reports, model adapters, dataset, and full H200 commands used for the submitted runs.\n",
+    "\n",
+    "The final submitted models were trained outside Colab on a RunPod H200 because Qwen3.5 9B + CADForge GRPO is too large for free Colab. The notebook does not pretend to rerun the full job; it proves the same training scripts and public dataset execute end-to-end on a tiny sample."
+   ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## What judges should check\n",
+    "\n",
+    "- The repo clone and dependency install succeed.\n",
+    "- The OpenEnv app validates.\n",
+    "- The public HF dataset loads.\n",
+    "- The CADForge reward smoke test compiles and scores real CadQuery.\n",
+    "- The 3-step SFT smoke run calls `training/train_sft_unsloth.py`, the same script used for the production SFT runs.\n",
+    "- The optional GRPO cell calls `training/train_grpo_cadforge.py`, the same script used for strict build-gated GRPO.\n",
+    "- The final report cells show the committed metrics and generated artifacts from the full H200 training run."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Public artifacts\n",
+    "\n",
+    "- Project repo: https://github.com/sanjuhs/open-env-meta-final-hackathon\n",
+    "- Hugging Face Space repo: https://huggingface.co/spaces/sanjuhs/cadforge-cadquery-openenv\n",
+    "- Training dataset: https://huggingface.co/datasets/sanjuhs/cadforge-cadquery-agentic-traces\n",
+    "- 2B SFT adapter: https://huggingface.co/sanjuhs/qwen35-2b-cadforge-sft-lora\n",
+    "- 2B GRPO adapter: https://huggingface.co/sanjuhs/qwen35-2b-cadforge-grpo-lora\n",
+    "- 9B SFT adapter: https://huggingface.co/sanjuhs/qwen35-9b-cadforge-sft-lora\n",
+    "- 9B GRPO adapter: https://huggingface.co/sanjuhs/qwen35-9b-cadforge-grpo-lora\n",
+    "- 9B strict build-gated GRPO adapter: https://huggingface.co/sanjuhs/qwen35-9b-cadforge-grpo-strict-build-lora"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Configure\n",
+    "\n",
+    "For a normal judge rerun, keep `RUN_SFT_SMOKE = True` and `RUN_GRPO_CADFORGE_SMOKE = False`.\n",
+    "\n",
+    "The SFT smoke is the best Colab-friendly proof that the training script is real. The CADForge reward smoke separately proves that the OpenEnv/CadQuery reward backend is real. GRPO is left optional because even a tiny CADForge GRPO run can be slow or memory-heavy on Colab T4/L4 runtimes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from pathlib import Path\n",
+    "\n",
+    "REPO_URL = \"https://github.com/sanjuhs/open-env-meta-final-hackathon.git\"\n",
+    "REPO_DIR = Path(\"/content/open-env-meta-final-hackathon\")\n",
+    "\n",
+    "# Public dataset produced for CADForge.\n",
+    "DATASET = \"sanjuhs/cadforge-cadquery-agentic-traces\"\n",
+    "\n",
+    "# Keep these small for public judge reruns.\n",
+    "RUN_SFT_SMOKE = True\n",
+    "RUN_GRPO_CADFORGE_SMOKE = False\n",
+    "SFT_SMOKE_STEPS = 3\n",
+    "\n",
+    "# Make the flags visible to subprocess-backed shell cells.\n",
+    "os.environ[\"RUN_SFT_SMOKE\"] = \"1\" if RUN_SFT_SMOKE else \"0\"\n",
+    "os.environ[\"RUN_GRPO_CADFORGE_SMOKE\"] = \"1\" if RUN_GRPO_CADFORGE_SMOKE else \"0\"\n",
+    "\n",
+    "# Optional. Only needed if you want to push adapters or access private repos.\n",
+    "os.environ.setdefault(\"HF_TOKEN\", \"\")\n",
+    "\n",
+    "BASE_2B = \"unsloth/Qwen3.5-2B\"\n",
+    "BASE_9B = \"unsloth/Qwen3.5-9B\"\n",
+    "print(\"Configured notebook smoke run\")\n",
+    "\n",
+    "import subprocess\n",
+    "import textwrap\n",
+    "\n",
+    "def run_bash(script: str, check: bool = True) -> None:\n",
+    "    \"\"\"Run a bash snippet from a normal Python Colab cell.\n",
+    "\n",
+    "    Colab occasionally makes bash-magic cells awkward to save or rerun from a\n",
+    "    shared notebook. Keeping shell commands behind this helper makes every cell\n",
+    "    valid Python while still running the exact production commands.\n",
+    "    \"\"\"\n",
+    "    env = os.environ.copy()\n",
+    "    env[\"PATH\"] = f\"{Path.home()}/.local/bin:\" + env.get(\"PATH\", \"\")\n",
+    "    subprocess.run(\n",
+    "        textwrap.dedent(script),\n",
+    "        shell=True,\n",
+    "        executable=\"/bin/bash\",\n",
+    "        check=check,\n",
+    "        env=env,\n",
+    "    )\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Clone and install\n",
+    "\n",
+    "This uses `uv` to match the production RunPod environment. The install can take several minutes on a fresh Colab runtime."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_bash(r\"\"\"\n",
+    "set -euo pipefail\n",
+    "\n",
+    "if [ ! -d /content/open-env-meta-final-hackathon/.git ]; then\n",
+    "  rm -rf /content/open-env-meta-final-hackathon\n",
+    "  git clone --depth 1 https://github.com/sanjuhs/open-env-meta-final-hackathon.git /content/open-env-meta-final-hackathon\n",
+    "else\n",
+    "  cd /content/open-env-meta-final-hackathon\n",
+    "  git fetch --depth 1 origin main\n",
+    "  git reset --hard origin/main\n",
+    "fi\n",
+    "\n",
+    "cd /content/open-env-meta-final-hackathon\n",
+    "curl -LsSf https://astral.sh/uv/install.sh | sh || true\n",
+    "export PATH=\"$HOME/.local/bin:$PATH\"\n",
+    "\n",
+    "export UV_CACHE_DIR=/content/.uv-cache\n",
+    "export HF_HOME=/content/.cache/huggingface\n",
+    "export TORCH_HOME=/content/.cache/torch\n",
+    "export TRITON_CACHE_DIR=/content/.cache/triton\n",
+    "export VLLM_CACHE_ROOT=/content/.cache/vllm\n",
+    "export UV_LINK_MODE=copy\n",
+    "export HF_HUB_ENABLE_HF_TRANSFER=1\n",
+    "export HF_HUB_DISABLE_XET=1\n",
+    "\n",
+    "uv sync --project experiment-2-cadforge\n",
+    "uv run --project experiment-2-cadforge python - <<'PY'\n",
+    "import numpy, trimesh, scipy, cadquery\n",
+    "print('CADForge project env OK:', numpy.__version__)\n",
+    "PY\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Validate the OpenEnv submission and inline reward backend\n",
+    "\n",
+    "This validates the OpenEnv app, then evaluates a small pasted CadQuery program through the real CADForge reward environment.\n",
+    "\n",
+    "The old root-level smoke command is kept as comments inside the cell because it can fail in Colab when `cadquery_env.py` runs outside the `experiment-2-cadforge` virtualenv. The working path is `uv run --project experiment-2-cadforge ...`, which gives the reward code access to `numpy`, `trimesh`, `scipy`, and `cadquery`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_bash(r\"\"\"\n",
+    "set -euo pipefail\n",
+    "cd /content/open-env-meta-final-hackathon\n",
+    "export PATH=\"$HOME/.local/bin:$PATH\"\n",
+    "\n",
+    "uv run --project experiment-2-cadforge openenv validate experiment-2-cadforge\n",
+    "\n",
+    "# Kept for reference only. In Colab this can run from the root uv env and miss\n",
+    "# numpy/cadquery/trimesh, which causes ModuleNotFoundError inside cadquery_env.py.\n",
+    "# uv run training/smoke_cadforge_reward.py --reward-mode fast\n",
+    "\n",
+    "cat > /tmp/cadforge_inline_candidate.py <<'CANDIDATEPY'\n",
+    "import cadquery as cq\n",
+    "\n",
+    "# Tiny editable wall-mounted J-hook for the notebook smoke test.\n",
+    "# This is deliberately simple so judges can verify the CADForge reward path quickly.\n",
+    "plate_w = 46.0\n",
+    "plate_h = 72.0\n",
+    "plate_t = 6.0\n",
+    "hook_len = 58.0\n",
+    "hook_t = 12.0\n",
+    "hook_drop = 34.0\n",
+    "rib_t = 8.0\n",
+    "hole_d = 6.0\n",
+    "\n",
+    "plate = cq.Workplane(\"XY\").box(plate_w, plate_t, plate_h).translate((0, 0, plate_h / 2.0))\n",
+    "\n",
+    "upper_hole = (\n",
+    "    cq.Workplane(\"XY\")\n",
+    "    .circle(hole_d / 2.0)\n",
+    "    .extrude(plate_t + 2.0)\n",
+    "    .translate((0, -1.0, plate_h * 0.72))\n",
+    ")\n",
+    "lower_hole = (\n",
+    "    cq.Workplane(\"XY\")\n",
+    "    .circle(hole_d / 2.0)\n",
+    "    .extrude(plate_t + 2.0)\n",
+    "    .translate((0, -1.0, plate_h * 0.28))\n",
+    ")\n",
+    "plate = plate.cut(upper_hole).cut(lower_hole)\n",
+    "\n",
+    "arm = cq.Workplane(\"XY\").box(hook_len, hook_t, hook_t).translate((hook_len / 2.0, 0, plate_h * 0.52))\n",
+    "tip = cq.Workplane(\"XY\").box(hook_t, hook_t, hook_drop).translate((hook_len, 0, plate_h * 0.52 - hook_drop / 2.0))\n",
+    "rib = cq.Workplane(\"XY\").box(hook_len * 0.65, rib_t, rib_t).translate((hook_len * 0.33, 0, plate_h * 0.38))\n",
+    "\n",
+    "fixture = plate.union(arm).union(tip).union(rib).clean()\n",
+    "CANDIDATEPY\n",
+    "\n",
+    "uv run --project experiment-2-cadforge python \\\n",
+    "  experiment-2-cadforge/python_tools/cadquery_env.py evaluate \\\n",
+    "  --code-file /tmp/cadforge_inline_candidate.py \\\n",
+    "  --episode-id notebook-inline-smoke \\\n",
+    "  --step-id pasted-cadquery-candidate \\\n",
+    "  --task-spec wall_j_hook_120n \\\n",
+    "  --task-prompt \"Design a simple editable wall mounted J hook with a wall plate, hook arm, support rib, and screw holes.\" \\\n",
+    "  --reward-mode fast\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Inspect the public training data\n",
+    "\n",
+    "The production scripts download from the same public Hugging Face dataset if local JSONL files are absent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_bash(r\"\"\"\n",
+    "set -euo pipefail\n",
+    "cd /content/open-env-meta-final-hackathon\n",
+    "export PATH=\"$HOME/.local/bin:$PATH\"\n",
+    "\n",
+    "uv run --with datasets --with huggingface_hub python - <<'PY'\n",
+    "from datasets import load_dataset\n",
+    "\n",
+    "repo = \"sanjuhs/cadforge-cadquery-agentic-traces\"\n",
+    "files = {\n",
+    "    \"sft_train\": \"data/sft/prompt_to_cadquery_train.jsonl\",\n",
+    "    \"repair_train\": \"data/repair/cadquery_repair_train.jsonl\",\n",
+    "    \"rl_rollouts\": \"data/rl/cadquery_rollouts.jsonl\",\n",
+    "}\n",
+    "for name, path in files.items():\n",
+    "    ds = load_dataset(\"json\", data_files={name: f\"hf://datasets/{repo}/{path}\"}, split=name)\n",
+    "    print(name, len(ds), list(ds[0].keys()))\n",
+    "PY\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Three-step SFT smoke training\n",
+    "\n",
+    "This runs the same SFT script used for the full runs, but with a tiny row limit and 3 optimizer steps. It is the Colab-friendly proof of the training entrypoint.\n",
+    "\n",
+    "The production SFT runs used longer schedules and larger context on RunPod H200. Those commands and reports are shown below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_bash(r\"\"\"\n",
+    "set -euo pipefail\n",
+    "cd /content/open-env-meta-final-hackathon\n",
+    "export PATH=\"$HOME/.local/bin:$PATH\"\n",
+    "export HF_HUB_DISABLE_XET=1\n",
+    "\n",
+    "if [ \"${RUN_SFT_SMOKE:-1}\" != \"1\" ]; then\n",
+    "  echo \"SFT smoke disabled in config.\"\n",
+    "  exit 0\n",
+    "fi\n",
+    "\n",
+    "CUDA_READY=$(python - <<'PY'\n",
+    "import torch\n",
+    "print('1' if torch.cuda.is_available() else '0')\n",
+    "PY\n",
+    ")\n",
+    "echo \"CUDA available: $CUDA_READY\"\n",
+    "if [ \"$CUDA_READY\" != \"1\" ]; then\n",
+    "  echo \"Skipping SFT smoke: switch Colab runtime to GPU, then rerun this cell.\"\n",
+    "  exit 0\n",
+    "fi\n",
+    "\n",
+    "uv run training/train_sft_unsloth.py \\\n",
+    "  --model unsloth/Qwen3.5-2B \\\n",
+    "  --output-dir outputs/notebook-qwen35-2b-cadforge-sft-3step \\\n",
+    "  --max-steps 3 \\\n",
+    "  --limit-train-rows 12 \\\n",
+    "  --limit-val-rows 4 \\\n",
+    "  --max-seq-length 2048 \\\n",
+    "  --per-device-train-batch-size 1 \\\n",
+    "  --gradient-accumulation-steps 1 \\\n",
+    "  --eval-steps 3 \\\n",
+    "  --save-steps 3 \\\n",
+    "  --lora-r 16 \\\n",
+    "  --lora-alpha 32 \\\n",
+    "  --load-in-4bit \\\n",
+    "  --run-name notebook-qwen35-2b-sft-3step\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Optional 3-step GRPO smoke\n",
+    "\n",
+    "This calls the actual GRPO training script with strict build gating and the real CADForge reward backend. Leave it disabled for quick judging; enable it only on a strong GPU runtime."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not RUN_GRPO_CADFORGE_SMOKE:\n",
+    "    print(\"GRPO CADForge smoke disabled by default. Set RUN_GRPO_CADFORGE_SMOKE = True in the config cell to run it.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_bash(r\"\"\"\n",
+    "set -euo pipefail\n",
+    "cd /content/open-env-meta-final-hackathon\n",
+    "export PATH=\"$HOME/.local/bin:$PATH\"\n",
+    "export HF_HUB_DISABLE_XET=1\n",
+    "export CADFORGE_PYTHON=/content/open-env-meta-final-hackathon/experiment-2-cadforge/.venv/bin/python\n",
+    "\n",
+    "GRPO_READY=$(python - <<'PY'\n",
+    "import os, torch\n",
+    "run = os.environ.get('RUN_GRPO_CADFORGE_SMOKE', '').lower() in {'1', 'true', 'yes'}\n",
+    "print('1' if run and torch.cuda.is_available() else '0')\n",
+    "PY\n",
+    ")\n",
+    "echo \"GRPO ready: $GRPO_READY\"\n",
+    "if [ \"$GRPO_READY\" != \"1\" ]; then\n",
+    "  echo \"Skipping optional GRPO smoke. Change RUN_GRPO_CADFORGE_SMOKE=1 in this cell and use a GPU runtime to run it.\"\n",
+    "  exit 0\n",
+    "fi\n",
+    "\n",
+    "uv run training/train_grpo_cadforge.py \\\n",
+    "  --model unsloth/Qwen3.5-2B \\\n",
+    "  --adapter outputs/notebook-qwen35-2b-cadforge-sft-3step \\\n",
+    "  --output-dir outputs/notebook-qwen35-2b-cadforge-grpo-3step \\\n",
+    "  --reward-backend cadforge \\\n",
+    "  --strict-build-gate \\\n",
+    "  --cadforge-python \"$CADFORGE_PYTHON\" \\\n",
+    "  --cadforge-reward-mode fast \\\n",
+    "  --limit-prompts 2 \\\n",
+    "  --max-steps 3 \\\n",
+    "  --num-generations 2 \\\n",
+    "  --max-prompt-length 2048 \\\n",
+    "  --max-completion-length 1024 \\\n",
+    "  --max-seq-length 4096 \\\n",
+    "  --per-device-train-batch-size 2 \\\n",
+    "  --gradient-accumulation-steps 1 \\\n",
+    "  --learning-rate 5e-6 \\\n",
+    "  --debug-completions-jsonl training/logs/notebook-grpo-3step-completions.jsonl \\\n",
+    "  --run-name notebook-qwen35-2b-grpo-3step\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Exact production scripts\n",
+    "\n",
+    "The full submitted run used the scripts below, not notebook-only code:\n",
+    "\n",
+    "- `training/train_sft_unsloth.py`\n",
+    "- `training/train_grpo_cadforge.py`\n",
+    "- `training/evaluate_cadforge_model.py`\n",
+    "- `training/make_training_report.py`\n",
+    "- `training/cadforge_training_pipeline.sh`\n",
+    "- `training/run_strict_9b_grpo.sh`\n",
+    "\n",
+    "The final strict GRPO run used build gating: failed CAD builds received negative reward, while successful builds unlocked dense topology, semantic, reference, and editability rewards."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run_bash(r\"\"\"\n",
+    "set -euo pipefail\n",
+    "cd /content/open-env-meta-final-hackathon\n",
+    "export PATH=\"$HOME/.local/bin:$PATH\"\n",
+    "\n",
+    "printf '\\n--- SFT script CLI ---\\n'\n",
+    "uv run training/train_sft_unsloth.py --help | sed -n '1,120p'\n",
+    "\n",
+    "printf '\\n--- GRPO script CLI ---\\n'\n",
+    "uv run training/train_grpo_cadforge.py --help | sed -n '1,180p'\n",
+    "\n",
+    "printf '\\n--- Strict 9B production wrapper ---\\n'\n",
+    "sed -n '1,220p' training/run_strict_9b_grpo.sh\n",
+    "\"\"\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. Production run evidence\n",
+    "\n",
+    "These reports are committed in the public repo and mirrored in the Hugging Face Space repo. They are the evidence for the real H200 training run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import Image, Markdown, display\n",
+    "from pathlib import Path\n",
+    "\n",
+    "repo = Path('/content/open-env-meta-final-hackathon')\n",
+    "report_dir = repo / 'training/reports/qwen35-9b-grpo-strict-build-20260426-strict-build'\n",
+    "\n",
+    "for image_name in ['grpo_reward_curve.png', 'grpo_code_health.png', 'grpo_error_breakdown.png']:\n",
+    "    path = report_dir / image_name\n",
+    "    if path.exists():\n",
+    "        display(Markdown(f'### {image_name}'))\n",
+    "        display(Image(filename=str(path)))\n",
+    "    else:\n",
+    "        print('Missing', path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import Markdown, display\n",
+    "from pathlib import Path\n",
+    "\n",
+    "repo = Path('/content/open-env-meta-final-hackathon')\n",
+    "for rel in [\n",
+    "    'training/RUNPOD_SMOKE_REPORT.md',\n",
+    "    'training/reports/qwen35-9b-grpo-strict-build-20260426-strict-build/training_curve_report.md',\n",
+    "    'training/eval/qwen35-9b-cadforge-grpo-strict-build-20260426-strict-build/eval_report.md',\n",
+    "]:\n",
+    "    path = repo / rel\n",
+    "    display(Markdown(f'## {rel}'))\n",
+    "    if path.exists():\n",
+    "        display(Markdown(path.read_text()))\n",
+    "    else:\n",
+    "        print('Missing', path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9. Summary of the submitted training run\n",
+    "\n",
+    "- Qwen3.5-2B SFT: train loss `1.4480 -> 0.1658`, eval loss `0.4477 -> 0.2676`.\n",
+    "- Qwen3.5-9B SFT: train loss `2.6020 -> 0.1413`, eval loss `0.3650 -> 0.2398`.\n",
+    "- Qwen3.5-9B strict GRPO: `320` completions, `96` buildable completions, best CADForge score `0.9352`.\n",
+    "- Quick held-out eval after strict GRPO: `2/3` prompts built successfully.\n",
+    "\n",
+    "The 3-step Colab run above is a reproducibility smoke test. The linked reports and adapters are the full training artifacts."
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "include_colab_link": true,
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.x"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}