@@ -136,6 +136,15 @@ Detection uses the FlagTree-only module `triton._flagtree_spec`. Note that
 empty string on nvidia/amd builds, since upstream directs you not to set
 `FLAGTREE_BACKEND` for those.
 
+PPU FlagTree currently queries `torch.cuda.current_device()` while selecting
+compiler hints. Inductor's asynchronous compile workers can make that query
+after a PPU CUDA context was initialized in the parent, which PyTorch rejects as
+CUDA reinitialization after `fork` ([FlagTree #1031](https://github.com/flagos-ai/FlagTree/issues/1031)).
+The flagos backend therefore defaults PPU FlagTree to one compile thread until
+the upstream driver no longer initializes CUDA in a worker. An explicit
+`TORCHINDUCTOR_COMPILE_THREADS` value or `compile_threads` compile option remains
+authoritative.
+
 ## Architecture
 
 ### Phase 1: Inductor Integration
 
@@ -75,6 +75,34 @@ print(f'Sample result: {y.cpu()[0, 0].item():.4f}')
 
 Expected output shows `torch.cuda available: True`, `torch.version.cuda: 13.0`, and a floating-point result.
 
+### `torch.compile` with FlagTree
+
+Build FlagTree from source with its PPU backend; the resulting `flagtree` wheel
+installs a `triton` module, so it must replace or shadow the vendor Triton:
+
+```bash
+git clone https://github.com/flagos-ai/FlagTree.git
+cd FlagTree
+pip install -r python/requirements.txt
+FLAGTREE_BACKEND=ppu MAX_JOBS=32 \
+  pip install . --no-build-isolation -v
+```
+
+Require the active compiler to be FlagTree and run the compile contract:
+
+```bash
+FLAGOS_DISABLE_CUDA_ASSETS=1 \
+  FLAGOS_USE_FLAGTREE=1 \
+  pytest tests/integration/test_compile.py -v --tb=short
+```
+
+PPU FlagTree currently initializes CUDA while selecting compiler hints in an
+asynchronous Inductor worker, which can fail after the parent process has already
+initialized the PPU context ([FlagTree #1031](https://github.com/flagos-ai/FlagTree/issues/1031)).
+Torch-FL defaults PPU FlagTree to serial compilation as a compatibility measure.
+Set `TORCHINDUCTOR_COMPILE_THREADS` explicitly only when testing an upstream fix
+or deliberately selecting a different worker configuration.
+
 ### AMP and GradScaler
 
 PPU uses the shared CUDA-boxing implementation, while the public AMP device name
 
@@ -280,6 +280,54 @@ def test_flagtree_requires_flagtree_install():
             require_flagtree()
 
 
+def test_ppu_flagtree_defaults_to_serial_compile(monkeypatch):
+    """PPU FlagTree must avoid CUDA initialization in forked compile workers."""
+    from torch_fl.compile import inductor_backend
+
+    monkeypatch.delenv("TORCHINDUCTOR_COMPILE_THREADS", raising=False)
+    monkeypatch.setattr(
+        "torch_fl.compile.flagtree_shim.flagtree_backend", lambda: "ppu"
+    )
+
+    patches = {}
+    inductor_backend._patch_ppu_flagtree_compile_workers(patches)
+
+    assert patches["compile_threads"] == 1
+
+
+def test_ppu_flagtree_preserves_explicit_compile_threads(monkeypatch):
+    """An explicit per-compile or environment setting remains authoritative."""
+    from torch_fl.compile import inductor_backend
+
+    monkeypatch.setattr(
+        "torch_fl.compile.flagtree_shim.flagtree_backend", lambda: "ppu"
+    )
+
+    patches = {"compile_threads": 4}
+    inductor_backend._patch_ppu_flagtree_compile_workers(patches)
+    assert patches["compile_threads"] == 4
+
+    monkeypatch.setenv("TORCHINDUCTOR_COMPILE_THREADS", "8")
+    patches = {}
+    inductor_backend._patch_ppu_flagtree_compile_workers(patches)
+    assert "compile_threads" not in patches
+
+
+def test_non_ppu_flagtree_keeps_default_compile_threads(monkeypatch):
+    """Other FlagTree backends keep Inductor's asynchronous compilation."""
+    from torch_fl.compile import inductor_backend
+
+    monkeypatch.delenv("TORCHINDUCTOR_COMPILE_THREADS", raising=False)
+    monkeypatch.setattr(
+        "torch_fl.compile.flagtree_shim.flagtree_backend", lambda: "hcu"
+    )
+
+    patches = {}
+    inductor_backend._patch_ppu_flagtree_compile_workers(patches)
+
+    assert "compile_threads" not in patches
+
+
 def test_flagtree_is_never_importable_as_flagtree():
     """Guard the packaging trap: the wheel is 'flagtree', the module is 'triton'.
 
 
@@ -104,6 +104,26 @@ def _resolve_config_patches(
     return patches
 
 
+def _patch_ppu_flagtree_compile_workers(config_patches: Dict[str, Any]) -> None:
+    """Keep PPU FlagTree compilation in the parent process by default.
+
+    FlagTree's PPU driver queries ``torch.cuda.current_device()`` while choosing
+    compiler hints. Inductor's asynchronous workers may be forked after the PPU
+    CUDA context is initialized, where that query triggers PyTorch's fork-safety
+    error. Serial compilation avoids the unsafe reinitialization until the
+    upstream driver can discover its device without touching CUDA in the worker.
+    """
+    if "compile_threads" in config_patches:
+        return
+    if os.environ.get("TORCHINDUCTOR_COMPILE_THREADS") is not None:
+        return
+
+    from torch_fl.compile.flagtree_shim import flagtree_backend
+
+    if flagtree_backend() == "ppu":
+        config_patches["compile_threads"] = 1
+
+
 def flagos_compile_backend(
     gm: torch.fx.GraphModule,
     example_inputs: List[torch.Tensor],
@@ -151,6 +171,8 @@ def flagos_compile_backend(
 
         require_flagtree()
 
+    _patch_ppu_flagtree_compile_workers(config_patches)
+
     # Make inductor treat flagos as a GPU device. Order matters: is_gpu() must
     # answer True and the device interface must be resolvable before the
     # codegen backend registration reads them.