PYTHON_QUARANTINE — runtime is C++/CUDA/Planck, Python is the surgery station behind glass

Doctrine, 2026-05-01. GIGACHAD_NATIVE is a sovereign C++/CUDA runtime. Python has no place in the living organism: not as router, not as organ logic, not as verifier in the production path, not as the thing deciding architecture. Python is allowed only as a disposable offline surgery capsule that produces non-Python artefacts the C++ runtime can mmap.

What is forbidden

• Python in the hot path. No Python process running during inference.
• Python as a router. The dispatcher in src/main.cpp::run_chat and the route classifiers in src/dispatcher/ are the only routers. No Python sidecar that decides what an organ runs.
• Python as organ logic. Every phys05_* and physarium_* is C++/CUDA producing tokens through the OrganManager against a .planck pack.
• Python as production verifier. verifier::verify_for_route in C++ owns acceptance. Python verifiers exist only inside tools/bench/*.py for measuring, never for gating runtime behaviour.
• Python deciding architecture. Schema, pack format, organ farm topology, BD store, dispatcher rules — all defined in C++ headers / source. Python doesn't get to mutate live structure.

A Python file that lives in src/ or build/ is a smell — investigate before merging.

What is allowed

Python is permitted only inside tools/surgery/, tools/bench/, or one-off scripts under scripts/, and only when the script is one of:

| Allowed Python role | Example | |-----------------------------------|--------------------------------------------------------| | Bench harness (offline) | tools/bench/mbpp_he_3mode.py, tools/bench/livecodebench_3mode.py, tools/bench/monster_integration_v1.py — call --chat, score outputs. Never live during user inference. | | Poison harvester | tools/surgery/bench_to_poison_dataset.py, tools/surgery/poison_to_dataset.py — read DAG / bench JSON, emit JSONL. | | QLoRA trainer (PEFT/PyTorch) | tools/surgery/train_code_skeleton_lora.py — train an adapter, save to disk. Once. Not invoked at runtime. | | Merge + repack | tools/surgery/merge_code_skeleton_lora.py — produce a fresh .planck pack. After this step Python is done. | | Probes / one-shot diagnostics | tools/surgery/identity_probe.py, _diagnose_memory.py — read state, print report, exit. |

Each of those is a disposable capsule. It runs to completion, drops a non-Python artefact (.planck, .jsonl, .md, .json), and is gone. The artefact crosses the glass into the C++ runtime; the Python process does not.

Output contract — what crosses the glass

The only legal outputs of a Python surgery capsule are:

1. A .planck pack consumed by OrganManager via mmap (build/planck7b_tool produces the pack from a merged HF dir).
2. A JSONL dataset under data/organ_surgery/<organ>/poison_train.jsonl (input to the next surgery, never read at runtime).
3. A report under reports/ (or its mirror in /mnt/c/Users/pc/Desktop/folder/reports/) that humans read.
4. A scoreboard / memory update noting the surgery happened.

If a Python tool wants to ship anything else into the live runtime — a .so, a daemon, a sidecar HTTP server, a pickle — that is a violation of this doctrine and must be rewritten in C++ before it is allowed near production code.

How this maps to BD6

The BD6 pass that closed 2026-05-01 followed the contract exactly:

bench failures (C++ runtime → reports/MBPP_HE_3MODE_V1.json)
  → tools/surgery/bench_to_poison_dataset.py            [Python]
    → data/organ_surgery/phys05_code_skeleton/poison_train.jsonl
      → tools/surgery/train_code_skeleton_lora.py       [Python, QLoRA, GPU]
        → tools/surgery/output/code_skeleton_lora/      [PEFT adapter on disk]
          → tools/surgery/merge_code_skeleton_lora.py   [Python, merge + planck7b_tool]
            → physarum05b_code_skeleton.planck          [BF16 pack — the artefact]
              → src/organs/organ_manager.cpp PHYS05_PACK retargeted
                → make -j4
                  → C++ runtime mmaps the new pack at boot
                    → Mode-B re-bench (NO_7B_FALLBACK=1, organ-only)
                      → reports/MBPP_HE_3MODE_V1.json overwritten
                        → reports/BD6_POST_SURGERY_DELTA.md

After the merge step, Python exits. The runtime does not import torch / peft / transformers. It mmaps the BF16 weights, runs them on the existing CUDA Q4 / DP4A path, and emits a DAG envelope. No Python in the request path, ever.

How to keep this doctrine alive

• When you write a new file in tools/surgery/ or tools/bench/, document its single artefact output at the top of the file (a .planck, a .jsonl, a reports/*.md).
• If a future task tempts you to add a Python service that the runtime calls — stop. Either (a) compile that logic into C++/CUDA, (b) make it produce a static artefact at build time, or (c) reject the task.
• Reviews should treat any new import of torch, peft, bitsandbytes, transformers, datasets, peft, or accelerate outside tools/surgery/ and tools/bench/ as a hard fail.
• External backends (llama.cpp, ExLlamaV2, AWQ-Marlin) follow the same rule — they are patients on the autopsy table per CLEAN_ROOM_DOCTRINE.md, not runtime dependencies. The BD6 capsule is the same shape: it touches Python only inside a glass box, then ships a pack.

The runtime is a body. Python is a scalpel. After the cut, the scalpel is washed and put back in the drawer.